POUG2026 | Poug

Agenda

Dzień 1 Dzień 2

Track 1

Track 2

Track 3

8:00-9:00

Track 1 Rejestracja

9:00-9:45

Track 1 "It Depends": Fact-Checking the Top 10 Myths of the PostgreSQL vs. Oracle Cold War rozwiń opis

There are two things that can start a fight at a tech conference: asking about the best text editor, and comparing PostgreSQL to Oracle. For years, we’ve been told that Oracle is the "Expensive Death Star" and Postgres is the "Plucky Rebel Alliance." But as any DBA who has actually been on-call at 3:00 AM knows: "Every database is a beautiful snowflake until it hits 10,000 transactions per second." In the enterprise world, the comparison between PostgreSQL and Oracle Database is often clouded by outdated biases: one is frequently labeled as "just a free alternative," while the other is dismissed as "legacy bloat." These stereotypes do a disservice to both technologies and the engineering teams that manage them.

This session is a constructive, objective, and — dare we say — humorous deconstruction of the Top 10 Myths that dominate the DB landscape in 2025. We’re moving past the tribalism to look at the cold, hard engineering reality. No blaming, no shaming, just a healthy dose of "here’s what actually happens." We aren’t here to pick a winner, we’re here to look at the architectural scars and the engineering triumphs of both to find the objective truth.. and to help you stop fighting the tools and just start building the architecture.

Prowadzący

Dirk Krautschick

Track 2 Lost in Time: Surviving the Time Zone Maze rozwiń opis

You’re familiar with Oracle’s well-known DATE datatype — it stores both date and time, down to the second — easy and simple. But what happens when your application goes global? Suddenly, what was “just a date” becomes a puzzle of offsets, daylight saving shifts, and unexpected conversions. One user’s “midnight” becomes another’s “yesterday,” and before you know it, you’re lost in time.

In this session, we’ll demystify the time zone maze inside the Oracle Database. We’ll take a practical look at the different datatypes — DATE, TIMESTAMP WITH TIME ZONE, and TIMESTAMP WITH LOCAL TIME ZONE — and understand what they really store, when to use which, and what traps to avoid.

We’ll explore how Oracle manages time conversions, how session and database time zones interact, and why “UTC everywhere” isn’t always the magic fix. Expect real-world coding examples, a few “gotcha” moments, and some fun facts about time zones along the way.

This session starts with the concepts and continues with hands-on examples to help you find your way through the time zone maze. By the end, you’ll have a solid strategy for storing and displaying time correctly in multi-time zone applications — and the confidence to keep your data (and your users) perfectly in sync, no matter where in the world they are.

Prowadzący

Giliam Breems

Track 3 From Prompt to App: Building on Oracle AI Database rozwiń opis

What happens when you give an AI coding agent a goal, a few prompts, and the right skills, then ask it to build and deploy a real web app? In this session, I’ll do exactly that live on stage. Using Claude Code, Codex, or a similar AI agent workflow, I’ll show how prompting, agent skills, and language SDKs can take an idea to a deployed application running on Oracle AI Database.

Prowadzący

Killian Lynch

10:00-10:45

Track 1 Beyond Vibe Coding — AI as Your Co-Developer rozwiń opis

Vibe Coding is everywhere — and it works surprisingly well for prototypes, proof of concepts and quick experiments. But what happens when the result needs to leave the playground and become real software? When you need multi-tenancy, security, a CI/CD pipeline and hundreds of unit tests?
Here's the thing: Vibe Coding and AI-assisted software development are not opposites — they are two sides of the same coin. One delivers fast results and validates ideas, the other turns those ideas into production-ready software. The key is knowing the strengths and limits of each approach and picking the right one at the right time.
I built a multi-tenant full-stack system entirely with AI assistance: Oracle 26ai with PL/SQL and ORDS, SvelteKit, Keycloak, Kubernetes on OCI — Liquibase, GitLab CI/CD and Terraform included. In this talk I share my hard-won lessons and best practices from the trenches:

Vibe Coding vs. AI-assisted development: Two approaches, one goal — and where each one breaks down
From prototype to production: When Vibe Coding stops working for you
Prompt engineering and context management: How to get the best out of your AI
What could possibly go wrong? War stories of hallucinated features, silent security holes and creative misunderstandings
Why blind trust is not an option — and how AI-powered code reviews still work
Architecture decisions with AI: Where the human stays in the loop

This talk is for developers and architects who want to use AI assistants beyond prototyping — and who want to know when to reach for which approach.

Prowadzący

Robert Marz

Track 2 From v$asm_file to mount: Building a Linux Filesystem on Top of Oracle ASM rozwiń opis

Oracle already knows everything about your ASM files — the names, the sizes, the physical locations. It exposes all of it through views like v$asm_file, v$asm_alias, and x$kffxp. The question is: what can you do with that information if you're willing to get a little creative?

This session walks through ASMFS (https://github.com/usrecnik/asmfs), an open-source tool that combines these views with direct block device reads to expose ASM files as a standard mountable Linux filesystem — no RMAN, no Data Pump, no manual extent hunting. Just cp, rsync, and anything else that speaks POSIX.

We'll look at how surprisingly little it takes to go from "I can query an extent map" to "I have a working filesystem mount" — and where things get interesting when you push these APIs beyond their comfort zone. Some of what ASM exposes is documented. Some of it lives in undocumented fixed tables. And some of it only revealed itself through plain experimentation — including a file header transformation that required flipping bytes until something stopped breaking.

Part live demo, part lessons-from-the-field — for anyone who has ever needed to get a file out of ASM and wished there was a simpler way.

Prowadzący

Urh Srečnik

Track 3 From Raw Data to RAG: Build AI Apps Faster in DB 26ai rozwiń opis

New in Oracle AI Database 26ai, the DBMS_VECTOR and DBMS_VECTOR_CHAIN packages provide simple and highly configurable procedures that developers can chain together to build their own AI applications backed by the database. Each procedure provides an out-of-the-box functionality for reading data and converting it to pure text, breaking the data into pieces (“chunks”), augmenting the chunks with metadata such as summaries, and vectorizing the data right inside of the DB. Developers have a choice of using an in-database ONNX model for the vector embedding or calling their favorite third party providers such as OCI GenAI, Cohere, Hugging Face, Google AI/Vertex, Mistral, and even locally hosted providers such as Ollama. Finally developers can easily access generative AI capabilities from the DB for any of these third party providers. The functionality provided by the DBMS_VECTOR and DBMS_VECTOR_CHAIN packages is also exposed via integrations with the popular Langchain and LlamaIndex frameworks in Python, Javascript and Java to increase developer productivity.

Prowadzący

Aleksandra Czarlinska

Ulrike Schwinn

11:00-11:45

Track 1 Cat Pics and Kill Chains - AI in Modern Warfare rozwiń opis

For many of us in IT, artificial intelligence is a favorite toy – or even a source of income. But it has long since become part of everyday military operations – and there’s a hot war in Europe, just 1,500 km from my home. AI there is used to kill people – and that’s no game. It’s supposed to tell tanks from tractors, control missiles and drones, optimize logistics, and support command structures. But wars are chaotic and improvised – sometimes low-tech beats high-tech, and even Goliath struggles when facing a pesky David. In this talk, we bring together military terminology, IT technology, and ethics: from staging areas to image recognition, from “effectors” powered by NVIDIA chipsets and trained models to the fully automated kill chain. We’ll examine the strengths and weaknesses of military AI systems, look at real-world examples from the war in Ukraine, and discuss ethical questions such as “meaningful human control,” "dual-use", and "ex-post accountability". This session is aimed at IT professionals who want to understand how technology and the military interact in wartime – without offering simple answers to complex questions.

Prowadzący

Martin Klier

Track 2 One Beer Must Always Remain in the Fridge rozwiń opis

Welcome to POUG! The fridge is full of beers. Help yourself and take as many as you like. But there’s one sacred rule: one beer must always remain. Kamil might show up at any moment, and if the fridge is empty, he won’t be happy… and you might not be invited back.
We’ve modeled this simple business rule in the database: SELECT COUNT(BEER) FROM FRIDGE must always be > 1. It’s simple if Luiza stands by the fridge, letting people in one by one and counting the beers. But the moment Luiza steps away, chaos. Everyone rushes to the fridge at once. Each sees two beers left, thinks they can grab one, and boom, the fridge is empty.
How can we enforce the rule in the database? We’ll explore options like serializable isolation, explicit locking, SQL assertions, and data modeling options - normalized or not.

Prowadzący

Franck Pachot

Track 3 Oracle Database as your Event Broker rozwiń opis

Oracle Transactional Event Queues (TxEventQ) enable event-driven architectures directly inside the database, removing the need for an external broker such as Kafka in many integration scenarios. This session demonstrates how to propagate real-time events between two Oracle databases using TxEventQ and database links. In addition, the packaged test environment inside Docker provides an isolated, reproducible playground for experimentation and testing.

This talk walks through a complete setup with two Oracle databases, each hosting TxEventQ topics, and a database link–based propagation pipeline to propagate JMS events between them.

This session targets database engineers, architects, and developers who want to introduce event-driven patterns into Oracle-based systems without adding new middleware layers. Attendees will leave with a working mental model and concrete scripts to reuse in their own environments to implement database-native event propagation.

Prowadzący

Jasmin Fluri

12:00-12:45

Track 1 Constraint Optimization: The Difference a Comma Can Make rozwiń opis

A task can be done in a very short way and in a very long way. Which one will you choose?

Knowledge is Power!

This session gives lots of interesting knowledge about an allegedly boring topic - Constraints. And this knowledge will give you the power to optimize and make better decisions.

The behavior of adding columns and constraints to big tables in Oracle may vary significantly, in two aspects - duration and availability - based on the way we perform these operations. In addition, different constraints may have different impact, based on their syntax, types, states, locking, etc.

Attend this session to understand what happens exactly under the hood when we issue a simple ALTER TABLE statement, and how to utilize this knowledge for achieving better performance or higher availability.

Prowadzący

Oren Nakdimon

Track 2 Painfully gained experience from the 4 years jam (tuning) session rozwiń opis

A large-scale migration from Oracle 11g/12c on traditional non-Exadata platforms to Oracle 19c on Exadata Cloud@Customer.

How large? Several thousand databases.
How long? Four years.
Did it all go smoothly and easily? Naturally not — that would have been far too boring.

This session is a recap of four years of ongoing tuning challenges which, interestingly enough, can be distilled into just a handful of recurring — and after all this time, almost suspiciously familiar — patterns.

Let us begin by meeting the usual suspects. I will gladly elaborate on each case in more detail:

- Beware of Estimated Cardinality = 1

- enq: TX - row lock contention: always the application’s fault?

- Hints: sometimes present, sometimes ignored — but why?

- Hash Join: are all columns really needed? Was SELECT * really a good idea?

- Offload with large SGAs: beware of caching effects (and trace NSMTIO)

- Same plan, same cardinality in each and every Plan ID, different elapsed time

- AWR analysis: is your AWR report genuinely helpful? (DB Time vs Elapsed Time)

- SQL*Net message from/to client: always idle, or only pretending to be?

Prowadzący

Piotr Sajda

Track 3 Oracle Private Agent Factory: your no-code, privacy-friendly, secure agents platform rozwiń opis

The wish to create AI agents is at its maximum. To satisfy this, a number of platforms allow you to easily build AI agents with no code required. By connecting pre-defined building blocks, you can create advanced workflows with AI capabilities.

You may not only want to build AI agents from scratch but also benefit from advanced prebuilt agents able to easily answer questions based on a set of sources, or a data analysis agent able to extract insights from a database.

Often, privacy is a concern with such kinds of platforms: “Who can see my data?” or “Why should I send my data out to an unknown cloud service to have an AI agent?” and the common “I want to run this locally, because I don’t trust anyone.”

Oracle answered these needs and concerns, and more, by introducing the Oracle AI Database Private Agent Factory. Run it on-premises, on your own hardware, run LLMs locally, and your data is safe and stays private inside your own corporate network. “How much?” you ask, and the answer is “free”! Or, run it in the cloud, but keep full ownership and control.

Join me to discover this product, which could look familiar if you are an n8n or comparable products user, and see what it does, how it does it, and give you ideas of interesting future usages.

Prowadzący

Gianni Ceresa

13:00-14:00

Track 1 Lunch

14:00-14:45

Track 1 Fighting Bad PL/SQL & SQL with Custom Rules rozwiń opis

In my previous talk, “Fighting Bad PL/SQL & SQL with VS Code”, I demonstrated how dbLinter helps detect bugs and improve code quality through automated checks and quick fixes. But what happens when the built-in rules are not enough?

This session takes the next step by showing how to create custom rules to enforce project-specific standards and catch issues that built-in linter rules cannot detect. You will learn how PL/SQL and SQL code is parsed, how custom validators work, and how to integrate your own rules and quick fixes into the linting process.

In a live demo, I will show:
- How to define a custom rule with compliant and non-compliant examples
- How to generate a validator skeleton
- How to visualise the parse tree of SQL and PL/SQL code
- How to implement and test a validator, including a quick fix
- How to activate the rule and use it in Visual Studio Code and the command line

By the end of this session, you will understand how dbLinter works behind the scenes and be able to recognise patterns in your own code where custom rules can help detect issues before they hit production.

Prowadzący

Philipp Salvisberg

Track 2 Performance Analysis & Tuning in ADB rozwiń opis

Oracle Autonomous AI Database is mostly self-governing. In cases performance analysis is still required, we show a layered approach: from easy to access first insights to in dept analysis.
Also some area of specific behavior and configuration are shown and their best utilization explained.

Prowadzący

Martin Berger

Dawid Welder

Track 3 Pints, Plans, and Parallel Agents: Debugging Oracle with Antigravity & Gemini CLI rozwiń opis

We all know the feeling: an ORA-00600 at 3 AM or a "simple" SQL refactor that touches 50 legacy packages. What if you had a team of junior DBAs who never sleep? This session moves past the AI hype to show how the Gemini CLI and the agent-first Google Antigravity IDE actually solve Oracle problems.

Prowadzący

Kiran Tailor

15:00-15:45

Track 1 Shape-Changing SQL rozwiń opis

There’s static SQL and dynamic SQL, but in between there’s also SQL that’s “dynamic at parse-time” (but not at runtime) - also known as polymorphic (meaning it can change “shape”.) This talk looks at different ways to achieve this, from ODCI over polymorphic functions to SQL macros.

- Description -

In PL/SQL on the one side we have static SQL that is plain fixed text in the source code and compiled together with the PL/SQL. On the other end of the spectrum we have dynamic SQL where a string containing SQL is built at runtime and parsed+executed with EXECUTE IMMEDIATE or DBMS_SQL.

In between those two ends, the spectrum over the versions are including more and more ways of doing SQL that is somewhere in-between; neither completely static in the source code, nor completely run-time dynamic. We can make SQL that is more or less dynamically built, but it is built during the hard parsing phase, leading to getting many benefits of static SQL along with some benefits of dynamic SQL. This can for various use-cases lead to better reusability of code in static SQL without necessitating dynamic SQL with its possible drawbacks. It can also sometimes be a way to expand the capabilities of SQL more performantly than PL/SQL functions.

Different methods exist in different versions for achieving such compile-time-dynamic SQL - ranging from Oracle Data Cartridge Interface (ODCI) over polymorphic table functions (PTFs) to SQL macros. This talk shows an overview of these methods, pros and cons, and when some methods are more applicable than others (and vice versa.)

- Notes -

This talk will take a look at:

• ODCI aggregate functions
• ODCI pipelined table functions
• Polymorphic table functions
• SQL table macroes

It will discuss use cases of each, potential benefits, drawbacks and pitfalls, and how to examine the actual SQL produced.

Prowadzący

Kim Berg Hansen

Track 2 Patching like a Pro - 2026 Edition rozwiń opis

Join this session to learn about the latest patching features for Oracle Database and how to patch your database like a hero, with minimal or zero downtime. We will cover the advanced features that can be used in patching strategies and how to keep your complex environments with Multitenant, Data Guard, RAC, and TDE up-to-date. A must-see for anyone who wants to stay away from bugs and attackers.

Prowadzący

Rodrigo Jorge

Track 3 Scouting 2.0: Player Similarity & Transfer Targets with 26ai Vector Search rozwiń opis

Recruiting is akin to finding a needle in a haystack: pinpointing tactical fits and value before competitors do. We embed per-90 performance data, event sequences, and short video descriptors into vectors within Oracle Database 26ai. Through the search function, we identify' players who play like X” across leagues and age groups; OML also incorporates injury risk and adaptability models. The demo illustrates a scout’s workflow: pick a reference player, view 26ai's nearest neighbours, explore explainable attributes, and export a report for presentation. Additionally, we will demonstrate a mini “what-if” analysis regarding salary and style fit.

Prowadzący

Abi Giles-Haigh

16:00-16:45

Track 1 SQL Assertions: The Greatest Database Feature You've Never Used rozwiń opis

You implemented primary and foreign keys in your database, sprinkled with unique and check constraints, all to keep your data in the best shape possible.
But what about data-rules that involves multiple tables, apart from referential integrity?
For example: the total amount of the order must be the sum of the related order lines. How can you guarantee that this rule is always true?
Changing amounts at order line level will impact this rule, as well as changing the order total amount.
Lots of database developers will try to implement a watertight solution with triggers while working their way around mutating table issues.

You wish there was something simple ... and there is: SQL Assertions.
SQL Assertions have been around since the early 1990's - at least on paper.
Until now there was no database vendor that actually implemented SQL Assertions. Oracle is the first vendor that has cracked the code and implemented SQL Assertions in Oracle Database 23ai.

This session will show all aspects of SQL Assertions, with many real world examples.

Prowadzący

Alex Nuijten

Roel Hartman

Track 2 Superpowers for DBAs: Architecting an Observability Agent with MCP and Oracle rozwiń opis

It’s every DBA’s nightmare: a critical latency alert—Friday at 5 PM—on a production database. Metrics are spiking, response times are exploding, and you have to find the needle in the haystack immediately.

But what if your database could not only alert you but also pre-diagnose the problem before you even open your terminal? In this session, we go beyond the agentic AI hype to dive into something concrete: building an autonomous agent for Oracle.

Far from a simple chatbot, we will explore through a live demo how the Model Context Protocol (MCP) transforms an LLM into a true DBRE expert, capable of securely interacting with Oracle internal performance metrics to diagnose and fix issues.

Prowadzący

Yves Colin

Track 3 Temporal Data Lineage and Impact Analysis in Oracle Database: Evolution to Oracle Graph Architecture rozwiń opis

What if you could answer not just "where does this data come from?" but "where did it come from six months ago?"

We present a production-validated solution that improves data lineage analysis by adding the missing time dimension. Built on the support for Property Graph, which is available in the Oracle Database, and integrated in Oracle APEX our platform enables analysts to travel back in time with visualization of data dependencies, transformations, and impact chains as they existed at any historical point.

Traditional lineage tools provide only current-state snapshots. But when regulators ask "show us how you calculated this metric during Q2 2023" or when investigating historical data quality issues, you need temporal intelligence. Organizations lose critical knowledge when developers leave, struggle with impact analysis of legacy systems, and face compliance challenges requiring historical auditability.

Key features:
• Time-travel lineage: View complete dependency graphs from any historical date
• Graph-based inference engine: Automatically resolves complex nested transformations across thousands of tables
• Oracle-native: Seamless integration with Oracle Graph and APEX Real-World Questions Answered:
• "Why did this report return that value on that date?"
• "What would have broken if we changed this table last quarter?"
• "When did this calculation logic change and who authorized it?"
• "Show complete data lineage as it existed during the audit period"

Attendees will gain practical implementation guidance for migrating to Oracle Graph, designing temporal property graphs, building rule-based inference engines, and delivering ROI through regulatory compliance, risk mitigation, and operational excellence.

Prowadzący

Tomislav Žarković

Karin Patenge

17:00-17:45

Track 1 We went SaaS.. and this is what happened (or didnt happen...) rozwiń opis

Trying to run systems and databases in the cloud... (bcse the in-house tech-stack became too expensive??). Both parties, customers and providers should by now have tackled most IaaS and SaaS problems..

We found out some problems never disappear. And New problems pop up all the time. But maybe you can learn something from what we did.

"Known" problems like "Latency and Bandwidth".. problems like row-by-row. But also new items like "That is not ours..???" and "How to Verify" .. We'll discuss the problems we came across as DBA and DataBase-Animals.

I'll try to give the DBA and Sysadmin some practical tips, tech-tricks even. But there are lessons for non-techies as well. And maybe you can Warn them up front and prevent some problems?

note; I'm just a few months in with this "wrestle-the-cloud" project, more news as we proceed... I'll straighten up the abstract as we go..

Prowadzący

Piet de Visser

Track 2 Time for Timeouts rozwiń opis

Sometimes you have to wait, but you can’t wait forever—so we have timeouts. In a modern tech stack, there are many kinds of timeouts, each belonging to a specific layer, from the operating system to database software. Most of these won’t be a problem until the day that particular layer becomes unavailable. For example, what happens to your database clients when you shut down one of the servers in a high-availability environment? This presentation explores the various types of timeouts you might encounter and what you can do to avoid unresponsive systems. It uses examples that will be familiar to Oracle database developers and administrators.

Prowadzący

Øyvind Isene

Track 3 Sizing your Database and Storage for Oracle AI Database 26ai rozwiń opis

Oracle AI Database 26ai introduces native support for vector data types, enabling AI and similarity search workloads directly within the database. This session will provide essential guidance on how to properly size your database and storage infrastructure in light of these advancements.

We’ll explore the storage implications of vector data, including typical size footprints per vector dimension, how vector data differs from traditional scalar types in terms of compression and I/O, and the significant storage overhead introduced by vector indexes. The session also includes insights into sizing considerations for mixed workloads, including traditional OLTP and AI workloads coexisting in a single database instance.

Attendees will leave with a practical framework for estimating growth due to vector data and indexes, understanding the impact on modern storage platforms, performance trade-offs, and planning capacity to ensure scalable, cost-effective deployments of Oracle AI Database 26ai.

Prowadzący

Ron Ekins

18:00-18:45

Track 1 Intelligent storage, a 20 year retrospective rozwiń opis

This will be the last Oracle talk I ever give. I'm retiring after working on Exadata offload for nearly 20 years. I'll recap the story of how we got here and give details on all the latest features that the storage layer can do including top-K vector search

Prowadzący

Roger MacNicol

Koniec

Track 1

Track 2

Track 3

9:00-9:45

Track 1 What’s Next for MySQL: Trends, Features, and Best Practices rozwiń opis

The MySQL ecosystem continues to evolve rapidly, driven by demands for scalability, real-time analytics, and cloud-native architectures. But with a steady stream of new features, continuously improving best practices, how can teams prepare for what’s next?

This session explores the current and emerging direction of MySQL, focusing on practical insights you can apply today while staying ready for tomorrow. The talk will also highlight relevant new capabilities and how they fit into existing production environments.

Attendees will leave with a clear view of MySQL's direction, practical guidance to keep their systems ready for the future, and a strong set of best practices that stay valuable across releases.

Prowadzący

Sławomir Maludziński

10:45

Track 1 Oracle SQLcl:The Free Tool Every PL/SQL and APEX Developer Needs rozwiń opis

Are you aware of the many features that SQLcl, a modern replacement of SQL*Plus, can offer to you, PL/SQL and APEX Developers? In this session, we will go through:
- SQLcl installation, configuration of startup/login scripts and managing database connections,
- AI and MCP Server - an easy way to let your database interact with Artificial Intelligence,
- Import/export data from files or directly from SQL Query or PL/SQL script,
- A simple way to import/export database schemas between environments using Data Pump
- APEX Export - an advanced and easy way to export APEX workspaces and applications,
- CODESCAN - built-in scanner that will reveal the quality of your PL/SQL and uncover potential performance issues
- CI/CD solution using “projects” command - an extension based on GIT and Liquibase to manage database changes

This session features practical examples that will enable you to start using SQLcl effectively and immediately.

Prowadzący

Rafał Grzegorczyk

Track 2 Oracle DBA discovers PostgreSQL rozwiń opis

You have spent a long and illustrious career working with Oracle. Then, out of the sudden, you're tasked with working with PostgreSQL. What next?

This presentation documents some of the more interesting differences from the practical, day-to-day perspective. Some differences, such as roles and schemas in PostgreSQL, are easy to spot. Some of the features, for example, tablespaces, work differently in PostgreSQL. Differences in observability and instrumentation are something you have to live with.

In addition, we will talk about what it takes to put a new application out to production in PostgreSQL. And since you might have existing services using the Oracle database, what does it take to migrate them to PostgreSQL while minimising the downtime?

Prowadzący

Priit Piipuu

Ilmar Kerm

Track 3 Stop Fixing AI’s Code. Start Teaching It! rozwiń opis

Tired of AI generating code that is ALMOST correct? Like any new employee, AI needs to understand our business context and domain before it can create useful results.
Fortunately, there are many ways for us to create a detailed context for our AI. Göran will show how a combination of database annotations, Oracle skills and custom instructions can let AI generate PL/SQL code that actually works in an Oracle database.

Prowadzący

Göran Paues

11:00-11:45

Track 1 Why Does the Optimizer Do That? Understanding Suboptimal and Unstable Execution Plans rozwiń opis

Ever wondered why the Oracle optimizer doesn't always pick the plan you expect or why the same query sometimes runs fast one day and slow the next? In this session, we'll demystify some of the inner workings of the Oracle optimizer, focusing on real-world scenarios where the "best" execution plan isn't chosen, or where plan instability causes headaches for DBAs and developers alike. We’ll discuss common scenarios, such as skewed data, stale statistics, bind variable peeking, and unpredictable environmental influences. We'll also take a look at solutions, because it's often easy to overlook a simple fix. Admittedly, the session can only cast a tiny light onto this huge topic, but it's based on the trials and tribulations of the Oracle Optimizer PM. Audience participation will be welcome.

Prowadzący

Nigel Bayliss

Track 2 What's new in the third edition of Troubleshooting Oracle Performance? rozwiń opis

The second edition of Troubleshooting Oracle Performance was published in 2014. Despite the fact that Oracle has introduced a number of major releases since then, the approach to solving database application performance problems has not changed. Nevertheless, it is of paramount importance to understand and utilize all the features offered by a specific version.
This session aims to summarize the most significant amendments to be included in the third edition of Troubleshooting Oracle Performance. It covers three types of topics: topics that were not documented, topics that were not documented precisely, and topics that were introduced by Oracle since 2014.

Prowadzący

Chris Antognini

Track 3 When Downtime Is Not an Option: Rollback-Safe Migration of Mission-Critical Databases in Telecom rozwiń opis

In this session, you will learn how a mission-critical telecom database migration was designed as a fail-safe and rollback-ready process under near-zero downtime constraints. The session explains how rollback capability was treated as a core architectural requirement rather than a contingency plan, ensuring that the system could be safely restored at any stage while operating under live traffic.

You will explore the challenges of cross-platform migration in always-on environments, including hidden system dependencies and behavioral differences that only emerge under real production load. The session also covers how the first migration attempt was intentionally aborted and cleanly rolled back within minutes, without data loss or customer impact, and how the same rollback-safe framework was later used to successfully complete the migration.

By the end of the session, you will gain practical insights into designing mission-critical database migrations that can fail safely, recover predictably, and ultimately succeed without compromising availability or business continuity.

Prowadzący

Kamran Aghayev

12:00-12:45

Track 1 Developers are like cats - they don't give a fuck. PL/SQL antipatterns. rozwiń opis

Developers are like cats. They really don’t give a fuck… until they suddenly do. And when they do, it’s usually because someone else has to clean up the mess they left behind.

In this highly opinionated and entertaining session, Erik van Roon dives deep into the most common (and most damaging) PL/SQL anti-patterns he has encountered during 30+ years of cleaning up other people’s code — and occasionally his own.

What You Will Learn

- The Psychology of the Code-Cat: Why developers ignore native SQL and default to imperative programming habits.
- Identify the Hairballs: How to spot the most dangerous PL/SQL anti-patterns before they reach PROD.
- Refactoring Destructive Code: Practical, high-performance replacements for common bad practices.

Prowadzący

Erik van Roon

Track 2 Kamil's worst nightmare: The Autonomous AI DBA rozwiń opis

Resistance is futile - and Oracle Autonomous AI Database and AI generally are here to stay. But how can a modern DBA benefit from it? What are the pros, the cons, the pitfalls and the rewards? And why is a migration so different but can be automated end-to-end already with AutoMigrate?

And how about AI in this relation? You can use it easily, it can help you - but there maybe a few thoughts needed upfront. Brain-control is important - we'll see how important it is.

This is a marketing-free session for techies, and people who like to go beyond and further.

Prowadzący

Mike Dietrich

Track 3 LGWR Beyond The Docs - What Oracle Didn't Write To Disk (Part 1) rozwiń opis

The database log writer (LGWR) has evolved into a highly adaptive, parallelized and dynamic component without any official explanation from Oracle on how it really works - time for a closer look!

This session is a technical deep dive into the following LGWR features that are not documented in the official Oracle manuals:

- Log parallelism
- Adaptive Log File Sync
- Exadata Fast Log File Sync

If you've ever observed strange redo wait events, unexplained LGWR behavior, or just want to understand what Oracle left out of the manuals, this talk is for you!

Prowadzący

Christoph Lutz

13:00-14:00

Track 1 Lunch

14:00-14:45

Track 1 Before I Trusted Databases: Building My Own Database System rozwiń opis

In my first job after university, I built my own database system. Why? Because I believed relational databases were too slow. At least that’s what I thought at the time.
While browsing through some old documents recently, I rediscovered my notes from the 1990s and immediately thought: this is nerdy enough for a POUG talk!
In this presentation, I will revisit the design of that homemade database system. It combined several concepts I had learned during my studies, including chained blocks, file system structures, and B-tree indexes. I will explain how these ideas were implemented and how the system actually worked.
Looking back, it was a fun and valuable exercise, but not something I would do again today. After many years working with Oracle databases, I have learned that relational databases are far more powerful and faster than my do-it-yourself database.

Prowadzący

Dani Schnider

Track 2 Tackling Data Guard limits: Some internals, how we improved, and plans for the near future rozwiń opis

Only for you, because you like to know how it works under the hood... Let’s deep dive into common, real-life scenarios that pushed Data Guard code to the limits, and how we tackled them.
You will hear about TLS vectored I/O, strong external authentication for redo transport (and the observer), ASYNC redo transport architectural changes, automatic redo prioritization, new AWR statistics for diagnosing network problems... all stuff that won't make any headline but will silently contribute to Data Guard’s performance, security, and service level compliance.

Prowadzący

Ludovico Caldara

Track 3 Securing ORDS REST services with JSON Web Tokens (JWT) rozwiń opis

ORDS REST services that return specific user related data need more authentication than just a client_id and client_secret. It must be ensured that a user only has access to his own data, and not the data of any other user. So in the REST service call we must determine the identity of the calling user, in a secure way. A good means to do this is by making use of JSON Web Tokens (JWT). In this session we will explain how JSON Web Tokens are put together, and how we can take advantage of the JWT features in the latest versions of ORDS. Also the use of JWT in APEX is discussed.

Prowadzący

André van der Put

15:00-15:45

Track 1 Why is the application so slow today? rozwiń opis

In this talk, I discuss the reasons for “poor” performance and why the database is always to blame. The focus is primarily on practical experience and the recurring need to adapt one’s own knowledge in response to changes in the Oracle Optimizer. But it also touches on stylistic quirks, bad weather, and the much-invoked work–life balance. A particularly interesting topic is the use of indexes—you know that already, don’t you? Or do you? Be prepared for surprises.

Prowadzący

Johannes Ahrends

Track 2 Using ORDS to upgrade your Oracle Databases rozwiń opis

Oracle AutoUpgrade makes database upgrades look almost trivial—but behind the scenes, it’s fully controllable and exposed through REST APIs. This session peels back that abstraction and treats AutoUpgrade not as a CLI tool, but as an API-driven upgrade framework.

We will explore how to drive and orchestrate database upgrades purely through HTTP, examine the internal job lifecycle and state machine, and map REST endpoints to the underlying upgrade phases. Along the way, we’ll look at how to build resilient, idempotent upgrade workflows, integrate AutoUpgrade into CI/CD pipelines, and gain real-time visibility into upgrade execution and failures.

Prowadzący

Julian Frey

Track 3 Dissecting Performance Tuning rozwiń opis

I still see SQL “performance tuning” that consists of random hints, superstition, bad indexing, voodoo, and parameter hacking, all applied with complete confidence and limited understanding. It’s not tuning. It’s hope.

Performance Tuning is not an art. It's not magic. It is the logical application of mathematical rules for deterministic outcomes.

Lets dissect Performance Tuning and see what happens in the real world as we try to avoid unintended consequences and look at what you really need to do for effective Performance Tuning.

Prowadzący

Neil Chandler

16:00-16:45

Track 1 Advanced Oracle Database Troubleshooting - Finding & Fixing A Bug On Your Own rozwiń opis

When you’re running an Oracle database version for that is no support (anymore), every unexpected issue becomes your responsibility. This talk dives into a real-world scenario where a critical bug surfaced in an unsupported release - no official patches, no vendor help.

Faced with the need for an immediate workaround, we’ll explore the process of diagnosing the issue from scratch, navigating undocumented behavior, and ultimately developing a fix independently. Along the way, you’ll gain insight into practical troubleshooting techniques with tools like GDB, Ghidra and Radare2.

Whether you’re a DBA or systems engineer, this session highlights the challenges and rewards of solving problems when there’s no safety net.

Prowadzący

Stefan Koehler

Track 2 Performance and the Man on the Clapham Omnibus rozwiń opis

"The Man on the Clapham Omnibus" is an important concept in British law - with similar expressions in many other countries for a "typical, ordinary, person". What this means in terms of the developer or DBA is hard to say, but it definitely excludes the likes of Kamil, Tanel, or even me, who spend far too much time hammering out the tiniest details of how Oracle works (or not).

For the person who is interested in Oracle, enjoys their job, and would like to feel less pressured when facing performance problems this session is a checklist (almost) of how to approach, learn from, and solve the performance problems that Oracle-based systems are likely to hit you with.

Prowadzący

Jonathan Lewis

Track 3 Exascale - what's that all about? rozwiń opis

Many of us gray-haired DBAs remember the shock when we first used ASM. Where did my storage go? Why can't I see the available space with df?

Now that DBAs have become familiar with ASM, it's time for a new way to store database files - Exascale.

This session will take a look at what's going on with Oracle's latest storage offering. We'll take a look at what it is, where it's available for use, why to use it, and provide commands for how to get through your basic tasks when using Exascale.

Prowadzący

Andy Colvin

Koniec

Kraków, 4-5 września

Dlaczego POUG?

Ta jedna konferencja, na której chcesz być on-site

Agenda

Prelegenci

Jak dojechać

Centrum Konferencyjne Fabryczna 13

After party

Zostań sponsorem

Zgłoszenie