Procedural Programming with

PostgreSQL PL/pgSQL: Design

Complex Database-Centric Applications
with PL/pgSQL 1st Edition Baji Shaik
Visit to download the full and correct content document:
https://textbookfull.com/product/procedural-programming-with-postgresql-pl-pgsql-des
ign-complex-database-centric-applications-with-pl-pgsql-1st-edition-baji-shaik/
More products digital (pdf, epub, mobi) instant
download maybe you interests ...

Beginning PostgreSQL on the Cloud: Simplifying Database

as a Service on Cloud Platforms Baji Shaik

https://textbookfull.com/product/beginning-postgresql-on-the-
cloud-simplifying-database-as-a-service-on-cloud-platforms-baji-
shaik/

PostgreSQL for data architects discover how to design

develop and maintain your database application
effectively with PostgreSQL Maymala

https://textbookfull.com/product/postgresql-for-data-architects-
discover-how-to-design-develop-and-maintain-your-database-
application-effectively-with-postgresql-maymala/

Exam Ref Pl 900 Microsoft Power Platform Fundamentals

Craig Zacker

https://textbookfull.com/product/exam-ref-pl-900-microsoft-power-
platform-fundamentals-craig-zacker/

Complex Analysis with Applications 1st Edition Nakhlé

H. Asmar

https://textbookfull.com/product/complex-analysis-with-
applications-1st-edition-nakhle-h-asmar/
Elementary Logic with Applications A Procedural
Perspective for Computer Scientists 1st Edition D.M.
Gabbay

https://textbookfull.com/product/elementary-logic-with-
applications-a-procedural-perspective-for-computer-
scientists-1st-edition-d-m-gabbay/

PostgreSQL Server Programming - Second Edition Dar

https://textbookfull.com/product/postgresql-server-programming-
second-edition-dar/

Learning PostgreSQL 10 A beginner s guide to building

high performance PostgreSQL database solutions Juba

https://textbookfull.com/product/learning-
postgresql-10-a-beginner-s-guide-to-building-high-performance-
postgresql-database-solutions-juba/

SQL Server Database Programming With Visual Basic NET

Concepts Designs and Implementations Ying Bai

https://textbookfull.com/product/sql-server-database-programming-
with-visual-basic-net-concepts-designs-and-implementations-ying-
bai/

National Brands and Private Labels in Retailing First

International Symposium NB PL Barcelona June 2014 1st
Edition Juan Carlos Gázquez-Abad

https://textbookfull.com/product/national-brands-and-private-
labels-in-retailing-first-international-symposium-nb-pl-
barcelona-june-2014-1st-edition-juan-carlos-gazquez-abad/
Baji Shaik and Dinesh Kumar Chemuduru

Procedural Programming with

PostgreSQL PL/pgSQL
Design Complex Database-Centric Applications
with PL/pgSQL
Baji Shaik
Texas, TX, USA

Dinesh Kumar Chemuduru

Andhra Pradesh, India

ISBN 978-1-4842-9839-8 e-ISBN 978-1-4842-9840-4

https://doi.org/10.1007/978-1-4842-9840-4

© Baji Shaik and Dinesh Kumar Chemuduru 2023

This work is subject to copyright. All rights are solely and exclusively
licensed 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.

The use of general descriptive names, registered names, trademarks,

service marks, etc. in this publication does not imply, even in the
absence of a specific statement, that such names are exempt from the
relevant protective laws and regulations and therefore free for general
use.

The publisher, the authors, and the editors are safe to assume that the
advice and information in this book are believed to be true and accurate
at the date of publication. Neither the publisher nor the authors or the
editors give a warranty, expressed or implied, with respect to the
material contained herein or for any errors or omissions that may have
been made. The publisher remains neutral with regard to jurisdictional
claims in published maps and institutional affiliations.
This Apress imprint is published by the registered company APress
Media, LLC, part of Springer Nature.
The registered company address is: 1 New York Plaza, New York, NY
10004, U.S.A.
I extend this dedication to Afrah Razzak, my exceptional wife. Her
enduring support and remarkable patience during the extended writing
sessions have been invaluable to me.
—Baji Shaik
I lovingly extend this dedication to my dear friend, Baji Shaik. Your
unwavering support and encouragement have been my guiding light,
especially in the most challenging moments. Your belief in me has been a
constant source of inspiration, and I am grateful for your presence in my
journey. This book is as much a tribute to our friendship as it is a
testament to the power of steadfast camaraderie. Thank you for always
being there.
—Dinesh Kumar Chemuduru
Introduction
The PostgreSQL engine comes with its own dedicated procedural
language, similar to procedural languages found in other commercial
database engines. This language, known as PL/pgSQL, offers a range of
powerful features that developers have long desired. For instance,
PL/pgSQL includes certain object-oriented programming capabilities
like the ability to define custom operators and types, as well as custom
aggregates.
In contrast to other programming languages supported by
PostgreSQL, PL/pgSQL is intricately linked with the PostgreSQL
database engine interface. This tight integration ensures optimal
performance and a seamless fit for constructing business logic on the
database side. In this book, we not only introduce the fundamentals of
PL/pgSQL, but we also dive deep into specific use cases that we’ve
implemented for particular scenarios. Our aim is to comprehensively
cover the various features, functionalities, and application scenarios of
PL/pgSQL, offering assistance in crafting effective server-side objects
with ease.
Through the content of this book, you will gain an understanding of
PL/pgSQL’s design and dive deep into its transaction model, including
how commit and rollback operations function. You’ll discover strategies
for optimizing PL/pgSQL functions and procedures and explore the
mechanics of inline or anonymous server-side code, along with its
limitations. Furthermore, you’ll acquire insights into debugging and
profiling PL/pgSQL code and learn techniques for conducting statistical
analyses on the PL/pgSQL code you create.
Any source code or other supplementary material referenced by the
author in this book is available to readers on GitHub
(https://github.com/Apress). For more detailed information, please
visit https://www.apress.com/gp/services/source-code.
Acknowledgments
I would like to express my gratitude to several individuals who have
played a crucial role in making this book a reality. A heartfelt thank-you
to Apress Media for providing me with this valuable opportunity. I am
especially grateful to my coauthor and mentor, Dinesh Kumar
Chemuduru, for his exceptional collaboration. I want to express my
gratitude to Divya Modi and Nirmal Selvaraj for being understanding of
our hectic schedules and providing us with continuous support
throughout the entire process. Special thanks to Deepak Mahto for his
thorough review of the book. Lastly, I am profoundly thankful to my
parents, Lalu Saheb Shaik and Nasar Bee, whose unwavering support
has shaped me into the person I am today.

—Baji Shaik

I would like to extend my heartfelt gratitude to a remarkable group

of individuals who have been instrumental in making this endeavor a
reality. My heartfelt thank-you to Apress Media for providing me with
this valuable opportunity. A special note of appreciation to my
esteemed coauthor, Baji Shaik. Sincere thanks to Deepak Mahto, whose
meticulous review and insightful feedback significantly enhanced the
quality and depth of this manuscript. To Divya Modi and Nirmal
Selvaraj, our project coordinators, your organizational skills and
dedication ensured that every aspect of this project fell seamlessly into
place. To my parents Vanamma, Sreenivasulu and my dearest children,
Yashvi and Isha, and to the future luminaries, Hema Siri K and Rahul
Sonu K – your unwavering love and understanding throughout the
demanding phases of this project have served as my steadfast anchor.
Your continuous support is my driving force.
Finally, a heartfelt thank-you to my exceptional team at Tessell. Your
commitment to excellence and innovation is awe-inspiring. Together,
we are shaping the future of DBaaS, and I am privileged to work
alongside such talented individuals.
—Dinesh Kumar Chemuduru
Table of Contents
Chapter 1:​Introduction to PL/​pgSQL
A Closer Look at PL/​pgSQL
PL/​pgSQL Installation
PL/​pgSQL Execution Flow
PL/​pgSQL Blocks
Anonymous or Unnamed Blocks
Named Blocks
Summary
What’s Next
Chapter 2:​PL/​pgSQL Variables
What Are Variables in PL/​pgSQL?​
Declaring Variables
Variable Scope
Constant Variables
Variable Alias
Scalar Variables
Array Variables
Record Variables
Cursor Variables
Summary
What’s Next
Chapter 3:​PL/​pgSQL Data Types
Data Types
Declaring Variables with Data Types
Supported Types
 Base Type
Composite Type
Domain Type
Pseudo-Type
Range Type
Multirange Types
Summary
What’s Next
Chapter 4:​Dealing with Strings, Numbers, and Arrays
Strings
Function Format
Dealing with Null String
Numbers
Arrays
Example Use Cases
Strings
Numbers
Arrays
Summary
What’s Next
Chapter 5:​Control Statements
IF/​ELSE Statement
Cascading IF Statements
CASE Statement
Iterative Statement
LOOP Statement
 WHILE Statement
FOR Statement
Example Use Cases
Example 1
Example 2
Best Practices of Using Control Statements in PL/​pgSQL
Summary
What’s Next
Chapter 6:​Handling Arrays
Array Index
Array Length
Iterate Array
Find Duplicate Elements in Array
Append Elements to Array
Array Merge
Multidimensional​Arrays
Summary
What’s Next
Chapter 7:​Handling JSON
What Is JSON?​
Use Cases
Advantages and Disadvantages
Build PL/​pgSQL Functions for JSON
Indexing JSON Data
Other Useful JSON Functions
Summary
 What’s Next
Chapter 8:​Cursors
What Are Cursors?​
CURSOR Attributes
ISOPEN Attribute
FOUND Attribute
NOTFOUND Attribute
ROWCOUNT Attribute
Monitor Cursors
SCROLL Cursor
NO SCROLL Cursor
WITH HOLD Cursors
Refcursors
Summary
What’s Next
Chapter 9:​Custom Operators
Built-In Operators
Creating a Custom Operator
Simple Example
SCENARIO 1:​Case-Insensitive Comparison
SCENARIO 2:​Custom Data Type Math
SCENARIO 3:​Date Differentiate Operator
SCENARIO 4:​Custom Operator for Data Classification
Advantages
Disadvantages
Summary
 What’s Next
Chapter 10:​Custom Casting
Built-In Casts
Custom Casts
Creating a Custom Cast
Simple Example
SCENARIO 1:​Converting Custom Data Types
SCENARIO 2:​Custom Data Type to JSONB
Summary
What’s Next
Chapter 11:​Dynamic SQL
What Is Dynamic SQL?​
Syntax of Dynamic SQL in PL/​pgSQL
Simple Example
Use Cases of Dynamic SQL
Best Practices and Considerations for Dynamic SQL
1.​Preventing SQL Injection
2.​Sanitizing and Validating Inputs
3.​Security Concerns
4.​Performance Optimization
Summary
What’s Next
Chapter 12:​Building Functions and Procedures
Functions
Defining Functions
Calling Functions
 Categories
Immutable Functions
STABLE Functions
VOLATILE Functions
Procedures
Temporary Functions/​Procedures
VARIADIC Functions/​Procedures
Best Practices
Summary
What’s Next
Chapter 13:​Return Values and Parameters
Return Values
Simple Example
Different Ways to Return Values
RETURNS
RETURNS SETOF
RETURNS TABLE
OUT
Simple Difference Matrix
Different Examples for Each RETURN Type
Using SELECT Statements
Using RETURNS TABLE
Using RETURN NEXT
Using RETURNS SETOF TABLE
Using RETURNS SETOF Data Type
Using RETURNS RECORD
 Using RETURNS SETOF RECORD
Using OUT Parameters
Using INOUT Parameter
Summary
What’s Next
Chapter 14:​Handling Exceptions
Exceptions
GET DIAGNOSTICS
FOUND
Exceptions in PL/​pgSQL
Different Ways to Handle Exceptions in PL/​pgSQL
Using the BEGIN and END Statements
Using the RAISE Statement
Custom Exceptions
Rethrow Exceptions
ASSERT
Get Call Stack
Using the GET STACKED DIAGNOSTICS Statement
Advantages of Using Exceptions
Disadvantages of Using Exceptions
Summary
What’s Next
Chapter 15:​Triggers
What Are Triggers?​
Syntax
Simple Example
 Types of Triggers in PostgreSQL
Row-Level Triggers
INSTEAD OF Triggers
Statement-Level Triggers
Event Triggers
Advantages of Triggers
Disadvantages of Triggers
DROP Triggers
Summary
What’s Next
Chapter 16:​Transaction Management
Nested Transactions
Exception Handling
Summary
What’s Next
Chapter 17:​Aggregates
Custom Aggregate
Simple Example
State Transition Function
Final Function
Creating Custom Aggregate
Create Type
Create State Transition Function
Create Aggregate
Final Function
Summary
 What’s Next
Chapter 18:​Listen and Notify
Simple Example
Build Polling in psql
TCN Extension
Summary
What’s Next
Chapter 19:​PL/​pgSQL Essential Extensions
plprofiler Extension
Installation
Usage
plpgsql_​check Extension
Installation
Usage
Summary
Index
About the Authors
Baji Shaik
, currently serving as a Senior Database
Consultant at AWS Professional Services,
embarked on his journey into the world
of databases in 2011. Since then, his
expertise has encompassed an array of
database technologies, including Oracle,
PostgreSQL, EDB Postgres, Amazon RDS,
Amazon Aurora, Amazon Redshift, and
Greenplum. Baji’s extensive background
spans both depth and breadth,
showcasing his mastery in SQL/NoSQL
database technologies.
Baji stands out as a Database
Migration Expert, having successfully
developed numerous database solutions
that tackle complex business challenges,
particularly in migrating databases from on-premises environments to
Amazon RDS and Aurora PostgreSQL/MySQL. His prowess also extends
to performance optimization, having fine-tuned RDS/Aurora
PostgreSQL/MySQL databases to achieve remarkable performance
benchmarks.
With a passion for knowledge sharing, Baji has authored several
notable books on PostgreSQL, such as PostgreSQL Configuration,
Beginning PostgreSQL on the Cloud, and PostgreSQL Development
Essentials. His commitment to education and information
dissemination is further evident through his contributions to
conferences, workshops, and a multitude of insightful blogs within the
AWS blog community.

Dinesh Kumar Chemuduru

, an accomplished Principal Architect (OSS), brings a wealth of
experience to the realm of technology and open source solutions. With
a notable background at AWS as a
proficient database consultant, Dinesh
excelled in orchestrating numerous
successful database migrations. His
expertise extends to the open source
arena, where he has both crafted and
augmented solutions around
PostgreSQL, showcasing his commitment
to collaborative innovation.
A coding enthusiast at heart, Dinesh
finds joy in crafting applications using
Flutter, Golang, and C++, platforms
where his creativity knows no bounds.
His proficiency extends to the deployment phase, as he deftly navigates
Kubernetes to bring his coding creations to life. In the literary domain,
Dinesh stands as a coauthor of the esteemed PostgreSQL High
Performance Cookbook, a testament to his mastery of the subject matter.
Beyond his own works, he actively engages in the appraisal of fellow
authors’ PostgreSQL books, cementing his status as a valued participant
in the exchange of knowledge.
Dinesh’s impact reverberates through his open source
contributions, which include the inception and enrichment of projects
such as PTOR – an ingenious RPO/RTO/SLA calculator tailored for
PostgreSQL. Another tool, “hammerpost,” sets a benchmark for
synthetic parameter evaluation in PostgreSQL, seamlessly integrated
with HammerDB.
About the Technical Reviewer
Deepak Ramnandan Mahto
works as a PostgreSQL Database
Engineer at Google Cloud. He has been
working with PostgreSQL since 2018,
and he also worked as a database
migration consultant at AWS. He is also a
keen blogger and loves to publish
articles on migration, best practices, and
on cloud with PostgreSQL. He loves to
code and build database-related utilities
using PL/pgSQL and SQL.
© The Author(s), under exclusive license to APress Media, LLC, part of Springer
Nature 2023
B. Shaik, D. K. Chemuduru, Procedural Programming with PostgreSQL PL/pgSQL
https://doi.org/10.1007/978-1-4842-9840-4_1

1. Introduction to PL/pgSQL
Baji Shaik1 and Dinesh Kumar Chemuduru2
(1) Texas, TX, USA
(2) Andhra Pradesh, India

In this chapter, we will start with an introduction of PL/pgSQL, on what is

PL/pgSQL and what are the key features of it. We will talk about some
common use cases where PL/pgSQL is used. PL/pgSQL comes by default
when you install the PostgreSQL server. However, we will provide the
steps to install PL/pgSQL. We will explain how PL/pgSQL works with a
simple flow diagram. We will show some basic examples of PL/pgSQL
code blocks which are called anonymous and named code blocks.

A Closer Look at PL/pgSQL

PostgreSQL uses SQL (Structured Query Language) as a default query
language. SQL is a common domain-specific language for relational
databases. PostgreSQL uses some extensions and features to implement
the standards of SQL. In addition to SQL, PostgreSQL supports many
procedural languages like PL/pgSQL, PL/Java, PLV8, PL/Python, PL/Perl,
etc. Using these languages, you can create functions, stored procedures,
and triggers which will improve the performance by reducing the
multiple iterations to the databases.
PL/pgSQL is the most commonly used procedural language in
PostgreSQL. It is an extension of SQL. It is similar to Oracle's PL/SQL and
supports features like control structures, exception handling, variables,
loops, and conditional statements. These features help us to develop
complex database applications in an efficient way.
 When working on designing a complex business logic inside the
database, you would need to develop multiple SQLs which are sometimes
interdependent. Results of one SQL will be used by other SQLs. In this
case, running multiple SQLs increases the data flow between the database
and the client application and will cause performance bottlenecks due to
high data transfer through the network. To overcome this, you can use
stored procedures or functions.
PL/pgSQL supports stored procedures, functions, and triggers. A
stored procedure is a set of precompiled SQL statements which can be
executed repeatedly. Stored procedures can help to reduce network traffic
and improve performance by reducing the amount of data that needs to
be sent between the database and the client application.
The common use cases to use stored procedures or functions using
PL/pgSQL are
1. Improve data processing speed by using precompiled code through
stored procedures which will be faster than raw SQL queries.

2. Write more complex code using features like control structures,

exception handling, variables, loops, conditional statements, etc.

3. Using stored procedures or functions, you can create a reusable code

to call from the applications to save time and effort.

4. PL/pgSQL is portable across different operating systems and

platforms. This makes it easier to migrate code between different
environments.

5. Prevent unauthorized access and data breaches by controlling the

user authentication on stored procedures or functions.

6. Use triggers to implement constraints of business processes that

cannot be expressed as foreign keys or check constraints.

PL/pgSQL Installation
PL/pgSQL is already included in PostgreSQL, so if you have PostgreSQL
installed, you should have PL/pgSQL as well. However, you may need to
enable it if it is not already enabled. Here are the steps to enable
PL/pgSQL in PostgreSQL:
1. Install PostgreSQL psql client to connect to the database, or you can
use the pgAdmin client tool.
For Ubuntu, the following are the simple steps to install the client:
# Create the file repository configuration:

sudo sh -c 'echo "deb

http://apt.postgresql.org/pub/repos/apt
$(lsb_release -cs)-pgdg main" >
/etc/apt/sources.list.d/pgdg.list'

# Import the repository signing key:

wget --quiet -O -
https://www.postgresql.org/media/keys/ACCC4CF8.asc
| sudo apt-key add -

# Update the package lists:

sudo apt-get update

# Install the latest version of PostgreSQL. If you want a specific

version, use 'postgresql-12' or similar instead of 'postgresql':

sudo apt-get -y install postgresql-client-15

For Linux (RHEL), you can follow the steps here:

www.postgresql.org/download/linux/redhat/

2. Connect to the database and check if PL/pgSQL is already installed:

postgres=# \dx
List of installed extensions
Name | Version | Schema | Description
-----+---------+--------+-------------
(0 rows)
postgres=# select * from pg_extension where
extname='plpgsql';
 oid | extname | extowner | extnamespace |
extrelocatable | extversion | extconfig |
extcondition
----+---------+----------+--------------+---------
-------+------------+-----------+--------------
(0 rows)

3. Execute the following command to enable PL/pgSQL:

postgres=# CREATE EXTENSION plpgsql;

CREATE EXTENSION

4. Verify that PL/pgSQL is enabled by executing the following command:

postgres=# \dx
List of installed extensions
Name | Version
| Schema | Description
------ -+---------+------------+------------------
------------
plpgsql | 1.0 | pg_catalog | PL/pgSQL
procedural language
(1 row)
JavaScript
postgres=# select * from pg_extension where
extname='plpgsql';
oid | extname | extowner | extnamespace |
extrelocatable | extversion | extconfig |
extcondition
------+---------+----------+--------------+-------
---------+------------+-----------+-------------
16388 | plpgsql | 10 | 11 |
f | 1.0 | |
(1 row)
PL/pgSQL Execution Flow
PL/pgSQL is like every other “loadable, procedural language.” PL/pgSQL
gets loaded through a function manager called fmgr. The fmgr loads the
language handler when a procedural language function or procedure is
executed and calls it. The execution flow of PL/pgSQL code is similar to
that of other procedural programming languages, with parsing,
compilation, execution, and cleanup stages. However, PL/pgSQL code is
executed on the server side, which means that it has direct access to the
database and can perform database operations more efficiently than
client-side code.
On the first call of a PL/pgSQL function or procedure in a session, the
server first parses the code to check for syntax errors. The call handler
will “compile” a function statement tree once the code is parsed. When
the code is compiled, it turns into an internal form that the server can
execute more efficiently. SQL queries in the function are just kept as a
string at this point, and the expressions like the following are actually
SQL queries:

my_var := some_param * 10

The SQL queries are actually parsed at this point, and parser hooks
are used to replace variables/parameters with PARAM nodes in the parse
tree. The PL/pgSQL statement tree is very similar to a PostgreSQL
execution tree. After the parse and compile, the call handler then executes
that statement tree. On the first execution of a statement node that has an
SQL query in it, that query is prepared via the Server Programming
Interface (SPI). The SPI provides a simple and efficient way to execute
SQL commands, retrieve query results, and manipulate the database. The
compiled code is then executed by the server. Based on any variable and
control structure declaration, the server creates a new execution
environment for the PL/pgSQL code. If the PL/pgSQL code is a function or
stored procedure that returns a result set, the server will send the result
set back to the client. Once the execution of the code is complete, the
server will clean up any resources that were used by the PL/pgSQL code,
including variables and any temporary tables that were created.
Figure 1-1 represents the flow of execution.
Figure 1-1 PL/pgSQL execution flow
This diagram illustrates the high-level steps of the PL/pgSQL
execution flow. However, it's important to note that PL/pgSQL code can
be quite complex and may include multiple control structures, error
handling blocks, and nested and even recursive PL/pgSQL function calls
and trigger invocations and database operations. The actual execution
flow of a specific PL/pgSQL function or stored procedure will depend on
the specific code and logic used. This call hierarchy is not limited to
PL/pgSQL. All procedural languages share the common entry point of the
fmgr, so they can be mixed and matched in trigger and function call
stacks.

PL/pgSQL Blocks
PL/pgSQL is a block-structured language. The basic unit in any PL/pgSQL
code is a block. All PL/pgSQL code is composed of a single block or blocks
that occur either sequentially or nested within another block. There are
two kinds of blocks:
Anonymous or unnamed blocks (DO)
Named blocks (functions)

Anonymous or Unnamed Blocks

Anonymous or unnamed blocks are generally constructed dynamically
and executed only once by the user. It is sort of a complex SQL statement.
The following is the structure of an anonymous block, for example:

DO $$
[ <<label>> ]
[ DECLARE
-- Variable declaration here
]
BEGIN
-- Execute statements here
END [ label ];
$$;

Now, let us start with a simple hello world code block, which does not
have any name associated with it:

postgres=# DO
$$
BEGIN
RAISE NOTICE 'Hello World';
END;
$$;
NOTICE: Hello World
DO
In the preceding example, the RAISE NOTICE command will help
us to print the given message on the client console. As you can see here,
the block is declared without a name, and if you want to print Hello
World, then you have to repeat the same set of instructions again.
Now, let us print the Hello World line by line rather than in a single
line:

postgres=# DO
$o$
BEGIN
RAISE NOTICE $i$
Hello
World
$i$;
END;
$o$;

NOTICE:
Hello
World
DO

In the preceding example, we used different multiline specifiers. The

whole block got enclosed by $o$, and the inner Hello World got
enclosed by $i$. From this example, we can learn that in PL/pgSQL, we
can have the nested multiliners, where each multiline should follow its
own enclosure.
Now, let us write a nested BEGIN ... END inside a main BEGIN
... END block. Here is an example:

postgres=# DO
$$
BEGIN

BEGIN
RAISE NOTICE 'Hello World';
Another random document with
no related content on Scribd:
The Project Gutenberg eBook of Kaunis Saksa
This ebook is for the use of anyone anywhere in the United States
and most other parts of the world at no cost and with almost no
restrictions whatsoever. You may copy it, give it away or re-use it
under the terms of the Project Gutenberg License included with this
ebook or online at www.gutenberg.org. If you are not located in the
United States, you will have to check the laws of the country where
you are located before using this eBook.

Title: Kaunis Saksa

Sarja saksalaista lyriikkaa

Translator: Uuno Kailas

Release date: August 30, 2023 [eBook #71524]

Language: Finnish

Original publication: Porvoo: WSOY, 1924

Credits: Tuula Temonen

*** START OF THE PROJECT GUTENBERG EBOOK KAUNIS

SAKSA ***
KAUNIS SAKSA

Sarja saksalaista lyriikkaa

Runot valinnut ja kääntänyt

UUNO KAILAS

Porvoossa, Werner Söderström Osakeyhtiö, 1924

OTTO MANNISELLE,
suomentajamestarille
kunnioituksella omistettu.

SISÄLLYS:

Wolfgang von Goethe

Prometheus.
Friedrich Hölderlin
 Hyperionin kohtalolaulu.
Illassa.
Joseph von Eichendorff
Lapseni kuoltua
Ludwig Uhland
Hyvä ystävä
Kievarin tytär
Heinrich Heine
Ylösnousemuspäivänä.
Rouva Suru
Paul Heyse
Maailmanarvoitus.
Friedrich Nietzsche
Yksinäinen.
Carl Spitteler
Isä.
Otto Julius Bierbaum
Yön hetkin hiljaisin.
Detlev von Liliencron
Eräälle vainajalle.
Ennen hälinää.
Suuressa kaupungissa.
Viimeinen tahto.
Richard Dehmel
Merenkäyntiä.
Hermann Hesse
Musta ritari.
Hugo von Hofmannsthal
Elämys.
Otto Erich Hartleben
 Kuihtunut lehti.
Seikkailija.
Laulu elämästä.
Frank Wedekind
Laulu lapsiparasta.
Peter Altenberg
Mitä hän voi tehdä hänen tähtensä.
Pelko.
Carl Hauptmann
Kallioääniä.
Max Dauthendey
Sun silmäs hiljaiset.
Syväss’ astumme hiekassa.
Harmaat enkelit.
Gustav Schu¨ler
Ilta.
Franz Evers
Nuoruus.
Christian Morgenstern
Lintu Synkkämieli.
Metsän yössä.
Rainer Maria Rilke
Syksy.
Alfred Mombert
Puutarhassa.
Perhonen.
Meren pohjassa lepäsin.
Kuun tahi auringon nähden.
Else Lasker-Schu¨ler
Me kaksi.
Albert Ehrenstein
Vaeltajan laulu.
Epätoivo.
Franz Werfel
Puhtauden rukous.
Johannes Becher
Mielipuoli.
Walter Hasenclever
Kuolinilmoitus.
ESIPUHE.

En kuvittele käännössarjani kykenevän edes vähäisessäkään

määrässä kuvastamaan saksalaisen Iyriikan yleistä kehitystä:
pisarahan voisi kertoa kovin vähän valtamerestä. Runojen valintaa
eivät niin sanoakseni kirjallisuushistorialliset näkökohdat olekaan
sanottavasti sitoneet. Ensinnäkin olen varonut kajoamasta sellaisiin
runoihin, joita paraskaan käännös ei voisi edes lähennellä lyyrilliseen
pitoisuuteen nähden — mielestäni ei ole oikeutettua siirtää
suomenkieleen kuortakaan, jos kerran ydin valuu pois. Niinpä onkin
monta runoilijanimeä, joiden paikka oikeudella olisi saksalaista
lyriikkaa sisältävän antologian lehdillä, saattanut jäädä kokonaan
pois tästä valikoimasta. Goethen runoja en ole ryhtynyt kääntämään
siitä syystä että toisella taholla parhaillaan valmisteltaneen uutta
Goethe- valikoimaa; kuitenkin olen ottanut mukaan
»Prometheuksen, entisten käännösten pohjalla laadittuna
sovittelukokeena. Edelleen sisältyy tähän sarjaan ylimalkaan vain
uudempaa, tämän ja viime vuosisadan runoutta: tunnoiltaan meitä
ajankohtaisesti läheisemmin koskettavana. Koska toivon voivani
tuonnempana julkaista uuden valikoiman nimenomaan kaikkein-
nuorinta maailmanlyriikkaa, olen tällä kertaa vain niukasti ottanut
mukaan saksalaista ekspressionistista runoutta. Vaikka valitsemani
runot eivät aina olisikaan edustavimpia tekijöilleen, enempää kuin
saksalaiselle lyriikallekaan — siitä huolimatta, että useimmat niistä
sisältyvät arvokkaimpiin saksalaisiin antologioihin —, ei
käännössarjani silti välttämättömästi tarvinne jäädä lukijalle
vähemmän satoisaksi kuin jokin ankarasti »edustava»
käännösvalikoima. Sivutarkoituksitta puhtaasti lyyrillisenä sarjana se
on kenties vain voittanutkin siitä: kun olen valinnut käännettäväni
omia mieltymyksiäni tai mielijohteitani noudattaen, on
mieskohtaisesti läheinen suhteeni originaaliin päässyt lämmittämään
monta käännöstä. Tiedän hyvin, että moni kaunis kimallus on jäänyt
tämän kirjan lehdille — niinkuin tiedän senkin, että moni yhtä kaunis
kimallus on valunut läpi sormieni antamatta vangita itseään.

Mitä puhtaasti suoritukselliseen puoleen tulee, olen käännöksissä

luonnollisesti varonut runojen tunnearvojen polkemista. Suomalaisen
asun joustavuus on mielestäni ollut tärkeämpää kuin originaalin
turhantarkka noudattaminen. Parissa tapauksessa, jolloin runon
ydintä ei ole voinut pahoin silpomatta puristaa originaalin rytmiin,
olen turvautunut jonkunverran muunnettuun säerakennelmaan —
mikä määrätyillä edellytyksillä yleensä katsottaneenkin sallituksi.

Kaiken kaikkiaan uskallan toivoa, että tämäkin vähäinen

käännössarja — vaikka onkin vain pisara suuren meren vettä — vie
suomalaisen lukijan askeleen lähemmäksi sitä Saksaa, jota mikään
sorron kuolemanrengas ei voi tuhota: saksalaista ihmissydäntä sen
puhtaimmissa sykähdyksissä — lähemmäksi Kaunista Saksaa.

Helsinki, joulukuussa 1923.

Uuno Kailas.
WOLFGANG VON GOETHE (1749-
1832)

PROMETHEUS

Taivahas peitä, Zeus, sumupilvihin ja voimaasi niinkuin poika,

joka ohdakkeita katkoo, koe tammihin ja vuorten huippuihin.
Siten järkytä sentään et maatani minun, et majaani minun, jot’
et kattanut sinä, et liettäni minun, jonka loimotuksen
kademielin näet.

En auringon alla tunne kurjempaa kuin te, jumalat! Niukasti

ruokitte uhriveroilla, rukousten hengellä majesteettianne ja
nääntyisitte nälkään, elleivät lapset ja kerjurit houkkina toivois
vielä. Kun olin lapsi enkä tietänyt kättäni pitemmälle, eksynyt
katseeni kääntyi päivän puoleen, kuin olis siellä itkuni kuuleva
korva, sydän kuin minun, joka ahdistettua säälii.

Kuka auttoi mua titaanien väkivaltaa vastaan? Kuka

kuolosta pelasti minut ja orjuudesta? Tätä kaikkea etkö sä itse
tehnyt, pyhä, hehkuva sydän? Ja nuorena, hyvänä, petettynä
kiitosta hehkunut etkö pilvissä-nukkujalle?
 Sua kunnioittaa? Miksi? Liensitkö koskaan tuskia
raskautetun? Pyyhitkö koskaan kyyneltä ahdistetun? Minust'
eikö takonut miestä kaikkivaltias aika, iankaikkinen kohtalo
myös, minun herrani, Zeus, ja sinun? Luuletko ehkä: mun
pitäisi elämää vihata, erämaahan paeta, kun eivät kaikki
unelmat kypsyneet?

Tässä istun, teen ihmisiä oman kuvani mukaan, suvun

kaltaiseni, kärsimään, itkemään, nauttimaan, riemuitsemaan,
sua ylenkatsomaan kuin minä!
FRIEDRICH HÖLDERLIN (1770-1843)

HYPERIONIN KOHTALOLAULU

Ylhäällä valossa kuljette vienoilla kentillä, henget autuaat!

Jumal-ilmat väikkyvät koskevat otsaanne hiljaa niinkuin
soittajan sormet kieliä pyhiä.

Vailla kohtaloa, lailla nukkuvan rintalapsen henkivät

taivahiset, puhtaina säilyneet ujojen nuppujen suojassa.
Henkensä heidän iäti kukkiva on, ja silmien autuaitten syvä
katse tulvii iankaikkista, hiljaista kirkkautta.

Mutta ei meille missään rauhan sijaa suotu. Kärsivät

ihmiset hukkuvat, putoavat suin päin, sokkoina hetkestä
toiseen hetkeen kuin vesi putoaa kallionkieleltä kallionkielelle
tuntemattoman syliin.

ILLASSA
Jo laske, armas aurinko. Tunteneet he eivät sua, palvoen
pyhyyttäs: Sä oothan siivin vaivattomin raskautettujen yli
noussut.

Mä nousus, laskus näin, Valo, lempeät,

tää silmä sinut ymmärsi, ihanin!
Mä opin suuren palvomisen:
joi sydän lääkettä Diotiman.

Sua, taivaan sanansaattaja, kuuntelen,

sua, Diotima! Rakkaus, luotas sun
päin päivän kultaa silmä tämä
kiittäen kääntyi! Ja iloisemmin

nyt solisivat lähtehet, kukkien ol’ ihanampi, armaampi

hengitys, ja kultapilvist’ alas satoi siunaus eetterin, niinkuin
hymy.
JOSEPH VON EICHENDORFF (1788-
1857)

KAKSI RUNOA SIKERMÄSTÄ »LAPSENI

KUOLTUA»

Kevätvälkkeessä ulkona leikkii lapsonen. Sata seikkaa

nähtävää, kukin riemuun johtaa: joet virtaavat, kedot laajat
hohtaa. Näki illan katsovan takaa lehmusten. Kuvat kauniit
kaikki se katse himmentää. Ylt’ympäri kaikki niin äänettömäks
jää. Ja on kuin laaksoissa nyt sävel hiljaa soisi, kuin
maanpiirin tään ikävällä se vyöttää voisi; värit kuihtuvat, kaikki
on kelmeää.

Laps hämmästyy: mitä onkaan tää? Uni ruohojen soitossa

nyt hänet yllättää; käsin kylmin kukkaset koskevat sydämeen,
hymyhuulin hän nääntyy tuskaan suloiseen. Pyhä, kaunis
maa, emo kalpea, hiljainen suo pienelle suuta ja vie liki
sydäntään, ei koskaan päästä hänt’ enää sylistään, tilan laatii
lapselle pehmeän, lämpöisen luo kukkien, sammalen. –
 »Isä, äiti, miks tähteni itkettekään? Olen saapunut puistoon
kimmeltävään; suur’ on se ja laaja ja ihmeellinen, helo täällä
on kukkien kultaisten, somat lapset lentävät, siipiä väikkyy
joka suunnalla, lauluja ilma läikkyy. – Kevätpäiviltä mulle ne
tuttuja on, ne lens yli laaksojen, vuoriston, ne taivaalta huuteli
hilpein suin alas puistoon, jossa mä uneksuin. – Ja keskellä
kukkien kuultavaisten käy kaunein parvesta kaikkien naisten,
käy kaunis lapsonen rinnoillaan. – Soperrella en saata, en
itkeä saata, minä laulan vain, minä en voi laata, yhä riemulla
katselen vaan.»

***

Lyö tornikello jossain, ja yö on pohjaton, niin himmeä on

lamppu. Sun vuotees valmis on.

Ylt’ ympärillä talon

käy tuulet valittain.
Siell’ istumme me yksin
ja kuuntelemme vain.

On kuin sun täytyis tulla

ja oveen koputtaa,
kuin eksyksistä lapsi
taas taaton luokse saa.

Me hupsut, hupsut raukat! Yön tuska ankarin meit’ yhä

harhaan johtaa – sä pääsit kotihin.
LUDWIG UHLAND (1787-1862)

HYVÄ YSTÄVÄ

Oli ystävä mulla kerran, oli parhain päällä maan. Kun rummut
soi sotateillä, sama ain’ oli tahti meillä, hänen astuin
rinnallaan.

Tuli lentäen luoti jostain

mun, sunko se kutsuu pois?
Hänet vihki se rauhaan suureen;
hän vaipui jalkaini juureen
kuin itsestäin osa ois.

Käden kurkoittaa hän mulle, kun tähtään pyssylläin. En voi

minä kättäni antaa; päin ikuisen rauhan rantaa käy, ystävä,
viereltäin!

KIEVARIN TYTÄR
Jano kulkureill’ oli. Poikettiin
siis Reinin varrella kievariin.

»Hoi, muori, on olves oivaa, vai –?

Tytär myöskin sulla on kaunis kai?»

»Olut, viini on mainio kerrassaan,

tytär ainoa nukkuu paareillaan.»

Ja muori kulkurit nuoret nuo

vie tyttären mustan arkun luo.

Hikiliinaa heist’ eräs kohottaa

ja katsoo, mies surun-synkäks saa:

»Ah, päivästä tästä, jos kuollut et ois,

sua rakastamatta en olla vois!»

Pani toinen liinan paikoilleen

ja purskahti itkuun hiljaiseen:

»Voi, armas, että sä kuolitkin!

Sua monta vuotta jo rakastin.»

Mut kolmas ja nuorin kulkuri tuo,

hän on kalpea, neidolle suuta suo:

»Rakas ollut oot, rakas vieläkin,

iankaikkisuudessa rakkahin.»
HEINRICH HEINE (1799-1856)

YLÖSNOUSEMUSPÄIVÄNÄ

Ah armahin, kun jo arkussas sinä pimeässä nukut, minä

astuva oon alas hautahas, minun hyväilyihini hukut.

Sinun huulias hulluna suutelen,

tomu kylmä ja mykkä sinä!
Minä nauran ja itken ja vapisen,
tomu koht’ olen myöskin minä.

Sydänyöllä kun nurmen nukkujain

käy karkelo ylitse hautain,
me kaksi, me jäämme multaan vain
ja väliin samojen lautain.

Ja kun tuomiopäivänä kutsutaan kaikk’ kuollehet

mättähistään, sylityksin me jäämme nukkumaan. Me
piittaisimmeko mistään!
ROUVA SURU

Iloss’ onnen päivien kirkkaimpain elo kävi kuin hyttystanssi

vain. Monet ystävät mull’ oli rakkahat, kuin veljet he kanssani
jakoivat niin pöytäni parhaat herkut kuin markkanikin, nämä
serkut.

On onni ja viini haihtunut, ovat poissa ystävät kaivatut; jo

sammui päivänpaistehet, ovat hyttystanssit kuollehet. Pois
häipyvät hyttyset, veikot, kun tulevat murheen peikot.

Yön tuulet nurkissani soi,

Suru vuodettani vartioi.
Näen hällä viitan valkean,
yömyssyn ja nuuskarasian;
se narisee hirveästi,
Suru nyökkää ilkeästi.

Minä unta näin: tuli takaisin taas onneni päivin keväisin, tuli
ystävät, hyttystanssi, oi – naris silloin rasia – hitto soi! Unet
eivät kimmellä enää – Suru-vanhus niistää nenää.