Category: Sem categoria

Some ideas are bigger than the person who has them. This one has been living in my head for a long time, and now it’s real: Guinness World Records has officially accepted my challenge.

From September 4 to 7, 2026, I will teach an uninterrupted class on Introduction to SQL and Database Administration for more than 80 consecutive hours, live, in hybrid format, from a small city in the interior of Rio Grande do Sul, Brazil.

The current world record for the longest computer programming lesson stands at 60 hours. We’re going after 80h.

More Than a Record. A Statement About Education.

The project is called “A Aula Mais Longa” (The Longest Lesson), and the name is exactly what it sounds like. But it’s not about endurance. It’s not a stunt. It’s a declaration.

We live in a country where education is often seen as secondary, something that happens before the “real” career begins, or something reserved for those who already have access. I want to prove something different: that learning can be extraordinary. That students and teachers can be protagonists. That a city in the interior of Brazil can make world history.

The lesson starts on September 4 and ends on September 7: Brazil’s Independence Day. That’s not a coincidence.

What We’re Aiming For

The primary record we’re chasing is the Longest Computer Programming Lesson, officially accepted by Guinness World Records. The current benchmark is 60 hours. Ours will surpass 80.

But we’re not stopping at one title. During the event, we’ll also attempt to set or break records in categories including:

• Longest Lesson Attended (current reference: 78h 3min)
• Longest Continuous Student Attendance
• Most Users to Take an Online Computer Programming Lesson in 24 Hours (current reference: 112,314 participants)
• Longest Hybrid Technology Lesson
• Longest Online Lesson
• Longest University Lesson

The Scale of the Challenge

This won’t be a quiet classroom experiment. The event is designed for real impact, in real numbers:

• +10,000 simultaneous participants
• +1,000 professionals trained live
• +200,000 students impacted online
• +1 million people reached
• 4 days of continuous live streaming
• 800+ bite-sized learning clips generated from the content

The format is hybrid, in-person attendance in Três de Maio, RS, alongside full online participation. There are currently 50 in-person spots and 100 online spots for those who want to be officially part of the Guinness attempt. We’ll evaluate the public interest and review this number if it goes higher.

The Legacy That Stays

The record ends when the lesson ends. The legacy doesn’t.

Every piece of equipment used during the event will be donated to public education initiatives. The 80 hours of content will be edited into short modules and made freely available. Professionals trained during the event become multipliers, people who carry this knowledge forward into their communities and careers.

This is what I mean when I say it’s about education, not just a record. The Guinness certificate is the headline. The real story is what happens after.

What’s Next

We’re currently in the sponsorship and partnership phase (March–April 2026). Public registration is opened!

The final push press coverage, technical rehearsals, and pre-event media  happens in July and August. Then, September 4, we go live. For 80 hours.

If you want to follow this journey, be part of it, or just watch history happen in real time, keep an eye on aulamaislonga.com.br or longestlesson.com and follow in insta @aulamaislonga

The record is just the beginning.

— Prof. Matheus Boesing.

Oracle’s In-Memory Column Store (IMCS) has been in the database since 12c, but 23ai brings meaningful enhancements to this performance layer. If you use the In-Memory option, these changes deserve attention.

Automatic In-Memory (AIM) improvements:

Oracle 23ai refines the Automatic In-Memory feature — where Oracle automatically decides which segments to populate in the column store based on access patterns.

The 23ai version uses a more sophisticated heat map that accounts for:

• Query frequency AND recency
• Join column correlation (prefetching joined tables together)
• Current available In-Memory area utilization

-- Check AIM recommendations
SELECT segment_name, recommendation, reason
FROM   v$im_segments_detail
WHERE  imeu_size > 0
ORDER BY priority_score DESC;

In-Memory Hybrid Scans:

23ai introduces Hybrid Scans — the optimizer can now split a query between the In-Memory column store and on-disk row store within the same scan, when only part of the table fits in memory. This avoids the all-or-nothing limitation of earlier versions.

In-Memory for JSON:

Columnar storage is now available for JSON document columns, allowing analytical queries on JSON fields to benefit from In-Memory performance without projecting out JSON to relational columns first.

ALTER TABLE events INMEMORY;
-- JSON field analytics now use IMCS automatically
SELECT data.event_type, COUNT(*)
FROM   events
GROUP BY data.event_type;

Monitoring In-Memory effectiveness:

SELECT table_name, inmemory_size, bytes_not_populated,
       populate_status, ROUND(inmemory_size/1024/1024) AS size_mb
FROM   v$im_segments
ORDER BY inmemory_size DESC;

The IMCS continues to be one of Oracle’s most powerful performance tools. The 23ai enhancements make it smarter and more flexible.

Oracle 23ai enhances multivalue INSERT syntax, making it simpler to insert multiple rows in a single SQL statement without using INSERT ALL or PL/SQL loops.

Classic single-row INSERT (unchanged):

INSERT INTO products (product_id, name, price)
VALUES (1, 'Widget A', 9.99);

Multirow INSERT with VALUES list:

INSERT INTO products (product_id, name, price)
VALUES
    (1, 'Widget A',  9.99),
    (2, 'Widget B', 14.99),
    (3, 'Gadget X', 49.99),
    (4, 'Gadget Y', 79.99);

This is now standard Oracle SQL syntax. Before 23ai, you needed either:

-- Old INSERT ALL approach
INSERT ALL
  INTO products VALUES (1, 'Widget A',  9.99)
  INTO products VALUES (2, 'Widget B', 14.99)
SELECT 1 FROM DUAL;

Or a PL/SQL FORALL loop for bulk performance.

Performance characteristics

The new multirow VALUES syntax is parsed as a single statement, reducing parse overhead and network round trips. For small-to-medium batch inserts (hundreds of rows), it’s significantly more efficient than individual INSERT statements in a loop, and more portable than INSERT ALL.

Combining with RETURNING:

DECLARE
    TYPE t_ids IS TABLE OF NUMBER;
    v_ids t_ids;
BEGIN
    INSERT INTO products (product_id, name, price)
    VALUES (5, 'Pro Kit', 199.99),
           (6, 'Pro Kit+', 249.99)
    RETURNING product_id BULK COLLECT INTO v_ids;
END;

For application developers inserting from REST APIs or batch processing jobs, multirow VALUES is a welcome simplification. It’s been standard in PostgreSQL and MySQL for years. Oracle’s implementation follows the ANSI SQL standard.

A subtle but genuinely useful SQL improvement in Oracle 23ai is the ALIAS clause — the ability to define a column alias once and reuse it in other parts of the same query, without repeating the expression.

The problem it solves

In classic SQL, you can’t reference a column alias from the SELECT list in the WHERE clause or the GROUP BY clause of the same query. This leads to expression repetition:

-- Classic SQL: expression repeated three times
SELECT employee_id,
       salary * 12 AS annual_salary,
       TRUNC(salary * 12 / 1000) AS salary_band
FROM   employees
WHERE  salary * 12 > 50000     -- repeated expression
ORDER BY salary * 12 DESC;    -- repeated again

With the ALIAS clause (Oracle 23ai):

SELECT employee_id,
       salary * 12 AS annual_salary    ALIAS annual_salary,
       TRUNC(annual_salary / 1000)     AS salary_band
FROM   employees
WHERE  annual_salary > 50000
ORDER BY annual_salary DESC;

The alias annual_salary defined in the first SELECT expression can be referenced by subsequent expressions in the same SELECT list, in WHERE, GROUP BY, HAVING, and ORDER BY.

Practical analytics example:

SELECT
    region,
    SUM(revenue) AS total_revenue   ALIAS total_revenue,
    SUM(cost)    AS total_cost      ALIAS total_cost,
    total_revenue - total_cost      AS gross_profit,
    ROUND(gross_profit / total_revenue * 100, 2) AS margin_pct
FROM sales
GROUP BY region
HAVING gross_profit > 0
ORDER BY margin_pct DESC;

Clean, readable, no repeated expressions. This is exactly the kind of ergonomic improvement that makes SQL more maintainable at scale.

If you’ve ever had to port SQL from PostgreSQL or SQL Server to Oracle, you’ve probably hit this wall: Oracle uses MINUS where every other database uses EXCEPT. They do the same thing, but the name difference forces you to rewrite queries or maintain separate versions.

Oracle 23ai adds EXCEPT and EXCEPT ALL as aliases and extensions to the existing set operator vocabulary.

EXCEPT — equivalent to MINUS (distinct rows only):

-- Customers who placed orders in 2024 but NOT in 2025
SELECT customer_id FROM orders WHERE order_year = 2024
EXCEPT
SELECT customer_id FROM orders WHERE order_year = 2025;

This is identical to using MINUS. Both are now valid.

EXCEPT ALL — the new addition:

-- Returns all rows from the first query not in the second,
-- including duplicates
SELECT product_id FROM inventory_snapshot_jan
EXCEPT ALL
SELECT product_id FROM inventory_snapshot_feb;

EXCEPT ALL does not eliminate duplicates from either side before comparing. If a value appears 3 times in the first set and 1 time in the second, the result contains 2 occurrences. This is the behavior defined in ANSI SQL and already present in PostgreSQL.

INTERSECT ALL is also new:

Oracle 23ai also adds INTERSECT ALL for symmetric completeness — it returns matching rows including duplicates, preserving the lower count from either side.

Complete set operator list in Oracle 23ai:

For cross-database SQL portability alone, EXCEPT is a welcome addition.

Oracle 23ai introduces Annotations — a way to attach custom metadata to database objects and columns directly in the database, not in a separate spreadsheet or wiki page that goes out of date.

An annotation is a name-value pair (or just a name) attached to a table, column, index, view, or other object. Think of it like tags or labels on cloud resources, but for your schema objects.

Adding annotations when creating a table:

CREATE TABLE employees (
    employee_id  NUMBER         ANNOTATIONS (PrimaryIdentifier, DisplayOrder '1'),
    first_name   VARCHAR2(50)   ANNOTATIONS (UserFacing 'true', MaxLength '50'),
    salary       NUMBER(10,2)   ANNOTATIONS (Sensitive 'true', Audited 'true'),
    dept_code    VARCHAR2(10)   ANNOTATIONS (ForeignKey 'departments.dept_code')
)
ANNOTATIONS (BusinessDomain 'HumanResources', Owner 'HR Team');

Adding annotations to an existing object:

ALTER TABLE employees
    ANNOTATIONS (ADD Deprecated 'true', ADD MigratedFrom 'LEGACY_EMP');

Querying annotations:

SELECT object_name, column_name, annotation_name, annotation_value
FROM   user_annotations_usage
ORDER BY object_name, column_name;

Practical use cases:

• Mark columns as Sensitive for data classification tools
• Tag tables with BusinessDomain for impact analysis
• Add Owner metadata for accountability
• Flag deprecated objects with Deprecated so tooling can warn users
• Store application-specific metadata like UILabel or DisplayOrder

Before annotations, metadata like this lived in comments (fragile, hard to query), separate tables (manual sync), or external tools. Annotations make it a first-class citizen of the schema.

This feature also has a personal story for me — one I’ll be sharing in detail in September. Stay tuned.

One of the more architecturally significant features in Oracle 23ai is SQL Domains. A domain is essentially a reusable column specification — a named type that bundles a data type, constraints, default values, display formatting, and ordering rules. Define it once, apply it to as many columns as you want across your schema.

Creating a domain:

CREATE DOMAIN email_address AS VARCHAR2(255)
    CONSTRAINT email_fmt CHECK (REGEXP_LIKE(VALUE, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$'))
    DISPLAY UPPER(VALUE)
    ORDER LOWER(VALUE);

Using the domain in a table:

CREATE TABLE customers (
    customer_id   NUMBER,
    email         email_address,    -- domain applied here
    support_email email_address     -- same domain, second column
);

The constraint from the domain is automatically enforced on every column that uses it. If you later update the domain’s constraint, the change propagates.

More domain examples:

-- Positive monetary amounts
CREATE DOMAIN money_usd AS NUMBER(15,2)
    DEFAULT 0.00
    CONSTRAINT positive_amount CHECK (VALUE >= 0);

-- Status codes
CREATE DOMAIN order_status AS VARCHAR2(20)
    CONSTRAINT valid_status CHECK (VALUE IN ('PENDING','PROCESSING','SHIPPED','DELIVERED','CANCELLED'));

Querying domain metadata:

SELECT domain_name, data_type, char_length
FROM   user_domains;

Why domains matter

Without domains, every table that stores an email address has its own REGEXP constraint — or more likely, no constraint at all. Domains enforce consistency at the schema level. They’re the database’s way of saying “this concept means the same thing everywhere.”

This is a feature that benefits large teams and long-lived schemas the most. If you’re building from scratch in 2025, start using domains — your future self will thank you.