I've been experimenting with local LLMs that are reputed to be good at coding, to see whether they could help generate PL/SQL code.
To see what is possible at this moment in time, I used LM Studio to give some local LLMs one simple request:
"write an oracle pl/sql function to calculate the date of Easter sunday"

Of course this is a very limited test; just one question and a very limited number of LLM models.
But it's a lot of fun to run them locally and see what a fairly powerful PC (AMD Ryzen 9 5900X, 64 GB RAM, Nvidia 5060 Ti with 16 GB VRAM) can do.
And with most models, if you point out the obvious mistakes they will correct them (most of the time), leaving you with usable code - or at least, something you can rework into something useful.

I created a package with all the "first pl/sql result" functions the LLMs generated, so without any fine-tuning done - just some formatting applied to make them look more uniform.
Some results needed tweaking to get them to compile; I noted those changes, and added my comments, in the functions themselves. Check out the code below.

Since I already have a page to calculate Easter sunday, comparing that with the results (if any) of the LLMs is easy enough.
In the "Models and Results" overview below, I listed the models and variants I tested, plus some test results (for 1538 and 4909, which are the limits of the Gregorian calendar, and some years around now).
Only half of the models functions produced any results, of which only one half again got it right most of the time.
For the year 4909, those ones got a different result than my own function (which says April 13th instead of 14th).
Since they all agreed with one other, I assume my function is wrong on that one - but I haven't found a source online I trust 100% to verify this...
If you really want to dive into that calculation, here's a good starting point: https://en.wikipedia.org/wiki/Date_of_Easter.

So far, essentialai/rnj-1, google/gemma-3n-e4b, google/gemma-4-e4b and openai/gpt-oss-20b are my favourites. They are fairly small (and therefore quite fast) and produce useful results.
I didn't expect the larger versions of gemma3 and gemma4 to perform worse than their smaller siblings. Interesting.
Also surprising to see that google/gemma-4-e4b did a bit worse than google/gemma-3n-e4b. But as we all know, N=1 is not a comprehensive test...

Page

Identification
	Page ID	1199
	Name	(PL)SQL - Creating PL/SQL with LLMs
Css
	Inline	.class_warning { background-color: #ffd7b6; padding: 2px; } .class_ok { background-color: #c7ffb8; padding: 2px; }

Region

Identification
	Sequence	20
	Title	Models and Results
	Type	Report
Source
	Location	Local Database
	Query Type	Table
	Table Name	TED_P1199_V
	Order By Clause	model_name

Report Column

Identification
	Column Name	MODEL_NAME
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	Model Name

Report Column

Identification
	Column Name	VARIANT
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	Variant

Report Column

Identification
	Column Name	SIZE_GB
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	Size (GB)
Appearance
	Format Mask	fm990.0

Report Column

Identification
	Column Name	PARAMETERS
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	Parms (B)
Appearance
	Format Mask	fm990.0

Report Column

Identification
	Column Name	VERDICT
	Type	Standard Report Column
Heading
	Heading	Verdict
Appearance
	Format Mask	PCT_GRAPH:::80

Report Column

Identification
	Column Name	R_1583
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 1583
Column Formatting
	HTML Expression	<span class="#CLASS_1583#">#R_1583#</span>

Report Column

Identification
	Column Name	R_2026
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2026
Column Formatting
	HTML Expression	<span class="#CLASS_2026#">#R_2026#</span>

Report Column

Identification
	Column Name	R_2027
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2027
Column Formatting
	HTML Expression	<span class="#CLASS_2027#">#R_2027#</span>

Report Column

Identification
	Column Name	R_2028
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2028
Column Formatting
	HTML Expression	<span class="#CLASS_2028#">#R_2028#</span>

Report Column

Identification
	Column Name	R_2029
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2029
Column Formatting
	HTML Expression	<span class="#CLASS_2029#">#R_2029#</span>

Report Column

Identification
	Column Name	R_2030
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2030
Column Formatting
	HTML Expression	<span class="#CLASS_2030#">#R_2030#</span>

Report Column

Identification
	Column Name	R_2031
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2031
Column Formatting
	HTML Expression	<span class="#CLASS_2031#">#R_2031#</span>

Report Column

Identification
	Column Name	R_2032
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 2032
Column Formatting
	HTML Expression	<span class="#CLASS_2032#">#R_2032#</span>

Report Column

Identification
	Column Name	R_4909
	Type	Display as Text (escape special characters, does not save state)
Heading
	Heading	R 4909
Column Formatting
	HTML Expression	<span class="#CLASS_4909#">#R_4909#</span>

View

View
	Name	TED_P1199_V
	DDL	with iv_m as ( select 'essentialai/rnj-1' as model_name, 'Q8_0' as variant, 8.8 as size_gb, 8.3 as parameters, 80 as verdict from dual union all select 'google/gemma-3-12b' as model_name, 'Q8_0' as variant, 13.4 as size_gb, 12 as parameters, 20 as verdict from dual union all select 'google/gemma-3-27b' as model_name, 'Q4_0' as variant, 16.4 as size_gb, 27 as parameters, 20 as verdict from dual union all select 'google/gemma-3-4b' as model_name, 'Q4_K_M' as variant, 3.3 as size_gb, 4 as parameters, 20 as verdict from dual union all select 'google/gemma-3n-e4b' as model_name, 'Q8_0' as variant, 7.4 as size_gb, 6.9 as parameters, 85 as verdict from dual union all select 'google/gemma-4-26b-a4b' as model_name, 'Q4_K_M' as variant, 18 as size_gb, 26 as parameters, 50 as verdict from dual union all select 'google/gemma-4-e4b' as model_name, 'Q8_0' as variant, 9 as size_gb, 7.9 as parameters, 70 as verdict from dual union all select 'mistralai/devstral-small-2-2512' as model_name, 'F16' as variant, 48 as size_gb, 24 as parameters, 40 as verdict from dual union all select 'mistralai/devstral-small-2-2512' as model_name, 'Q3_K_L' as variant, 13.3 as size_gb, 24 as parameters, 40 as verdict from dual union all select 'openai/gpt-oss-20b' as model_name, 'MXFP4' as variant, 12.1 as size_gb, 20 as parameters, 95 as verdict from dual union all select 'qwen/qwen3-coder-next' as model_name, 'Q4_K_M' as variant, 48.5 as size_gb, 80 as parameters, 90 as verdict from dual union all select 'qwen/qwen3.5-35b-a3b' as model_name, 'Q4_K_M' as variant, 22.1 as size_gb, 35 as parameters, 40 as verdict from dual union all select 'qwen/qwen3.5-35b-a3b' as model_name, 'Q8_0' as variant, 37.8 as size_gb, 35 as parameters, 50 as verdict from dual union all select 'zai-org/glm-4.7-flash' as model_name, 'Q8_0' as variant, 31.8 as size_gb, 30 as parameters, 10 as verdict from dual ) ,iv_e as ( select ted_holiday.get_easter(p_year => 1583) as e_1583 ,ted_holiday.get_easter(p_year => 2026) as e_2026 ,ted_holiday.get_easter(p_year => 2027) as e_2027 ,ted_holiday.get_easter(p_year => 2028) as e_2028 ,ted_holiday.get_easter(p_year => 2029) as e_2029 ,ted_holiday.get_easter(p_year => 2030) as e_2030 ,ted_holiday.get_easter(p_year => 2031) as e_2031 ,ted_holiday.get_easter(p_year => 2032) as e_2032 ,ted_holiday.get_easter(p_year => 4909) as e_4909 from dual ) ,iv_r as ( select iv_m.model_name ,iv_m.variant ,iv_m.size_gb ,iv_m.parameters ,iv_m.verdict ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 1583) as r_1583 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2026) as r_2026 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2027) as r_2027 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2028) as r_2028 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2029) as r_2029 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2030) as r_2030 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2031) as r_2031 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 2032) as r_2032 ,ted_p1199.get_easter(in_model_name => iv_m.model_name, in_variant => iv_m.variant, in_year => 4909) as r_4909 from iv_m ) select iv_r.model_name ,iv_r.variant ,iv_r.size_gb ,iv_r.parameters ,iv_r.verdict ,iv_r.r_1583 ,iv_r.r_2026 ,iv_r.r_2027 ,iv_r.r_2028 ,iv_r.r_2029 ,iv_r.r_2030 ,iv_r.r_2031 ,iv_r.r_2032 ,iv_r.r_4909 ,(case when iv_r.r_1583 is null or iv_r.r_1583 <> iv_e.e_1583 then 'class_warning' else 'class_ok' end) as class_1583 ,(case when iv_r.r_2026 is null or iv_r.r_2026 <> iv_e.e_2026 then 'class_warning' else 'class_ok' end) as class_2026 ,(case when iv_r.r_2027 is null or iv_r.r_2027 <> iv_e.e_2027 then 'class_warning' else 'class_ok' end) as class_2027 ,(case when iv_r.r_2028 is null or iv_r.r_2028 <> iv_e.e_2028 then 'class_warning' else 'class_ok' end) as class_2028 ,(case when iv_r.r_2029 is null or iv_r.r_2029 <> iv_e.e_2029 then 'class_warning' else 'class_ok' end) as class_2029 ,(case when iv_r.r_2030 is null or iv_r.r_2030 <> iv_e.e_2030 then 'class_warning' else 'class_ok' end) as class_2030 ,(case when iv_r.r_2031 is null or iv_r.r_2031 <> iv_e.e_2031 then 'class_warning' else 'class_ok' end) as class_2031 ,(case when iv_r.r_2032 is null or iv_r.r_2032 <> iv_e.e_2032 then 'class_warning' else 'class_ok' end) as class_2032 ,(case when iv_r.r_4909 is null or iv_r.r_4909 <> iv_e.e_4909 then 'class_warning' else 'class_ok' end) as class_4909 from iv_r cross join iv_e

Package

Package
	Name	TED_P1199
	Source	package ted_p1199 is function essentialai_rnj_1_q8_0(year in number) return date; function google_gemma_3_12b_q8_0(year in number) return date; function google_gemma_3_27b_q4_0(year in number) return date; function google_gemma_3_4b_q4_k_m(in_year in pls_integer) return date deterministic; function google_gemma_3n_e4b_q8_0(p_year in number) return date; function google_gemma_4_26b_a4b_q4_k_m(p_year in number) return date; function google_gemma_4_e4b_q8_0(p_year in number) return date; function mistralai_devstral_small_2_2512_f16(p_year in number) return date; function mistralai_devstral_small_2_2512_q3_k_l(p_year in number) return date; function openai_gpt_oss_20b_mxfp4(p_year in number) return date; function qwen_qwen3_coder_next_q4_k_m(p_year in pls_integer) return date; function qwen_qwen3_5_35b_a3b_q4_k_m(p_year number) return date; function qwen_qwen3_5_35b_a3b_q8_0(p_year in number) return date; function zai_org_glm_4_7_flash_q8_0(in_year in pls_integer) return date; function get_easter ( in_model_name in varchar2 ,in_variant in varchar2 ,in_year in pls_integer ) return date deterministic; end ted_p1199;

Package Body

Package Body
	Name	TED_P1199
	Source	package body ted_p1199 is function essentialai_rnj_1_q8_0(year in number) return date is a number; b number; c number; d number; e number; f number; g number; h number; i number; k number; l number; m number; month_number number; day_number number; begin a := mod(year, 19); b := floor(year / 100); c := mod(year, 100); d := floor(b / 4); e := mod(b, 4); f := floor((b + 8) / 25); g := floor((b - f + 1) / 3); h := mod(19 * a + b - d - g + 15, 30); i := floor(c / 4); k := mod(c, 4); l := mod(32 + 2 * e + 2 * i - h - k, 7); m := floor((a + 11 * h + 22 * l) / 451); month_number := floor((h + l - 7 * m + 114) / 31); day_number := mod(h + l - 7 * m + 114, 31) + 1; return to_date('01-' || to_char(month_number) || '-' || year, 'DD-MM-YYYY') +(day_number - 1); /* Perfect! Result is April 5th 2026. I tested some other years as well and it worked for all of them. I did need to give it some more information however. After the original prompt it replied: "It seems like there is a bit of confusion in the question since you've asked for a Python code solution while the title mentions Oracle PL/SQL. However, I'll assume that you want a Python implementation to calculate the date of Easter Sunday." No idea why it would think that, but it did produce some Python code. I gave a further prompt: "I need this in oracle pl/sql", after which it produced the code shown above. Note that there is no check to validate the year. */ end; -- function google_gemma_3_12b_q8_0(year in number) return date is a number; b number; c number; d number; e number; f number; g number; easter_date date; begin -- Validate the year. Easter calculation is generally valid for years 3-4099. if year < 3 or year > 4099 then return null; -- Or raise an exception: RAISE VALUE_ERROR; end if; a := (year mod 4); b := (year mod 7); c := (year mod 100); d := (year mod 400); e := (2 - a + d) mod 7; -- This is the key calculation. f := (a * 5) + (b * 4) + c + e; g := f mod 7; -- Calculate Easter date based on Gregorian calendar rules if year < 2000 then easter_date := to_date(to_char(add_months(to_date('01-03-' || year, 'DD-MM-YYYY'), g - 1), 'DD-MM-YYYY'), 'DD-MM-YYYY'); else easter_date := to_date(to_char(add_months(to_date('01-03-' || year, 'DD-MM-YYYY'), g), 'DD-MM-YYYY'), 'DD-MM-YYYY'); end if; return easter_date; /* The code compiles, but that's about it - the calculation is nonsense */ exception when value_error then return null; -- Or raise the exception: RAISE; end google_gemma_3_12b_q8_0; -- function google_gemma_3_27b_q4_0(year in number) return date is a number; b number; c number; d number; e number; f number; g number; h number; i number; j number; m number; day number; month number; begin /* -- Calculate the values based on Gauss's algorithm a := year DIV 100; b := a DIV 4; c := a MOD 4; d := (year + 8) DIV 25; e := (year - d + 1) DIV 3; f := (year - 4 * b + c) MOD 7; g := year + e - d; h := g MOD 7; -- Calculate the day of the month for Easter Sunday i := (23 * h + 15) DIV 7; m := i; -- Determine the month and day IF m = 28 THEN day := 31; month := 4; -- April ELSIF m = 29 THEN day := 6; month := 4; -- April ELSIF m = 30 THEN day := 5; month := 4; -- April ELSIF m = 31 THEN day := 4; month := 4; -- April ELSE day := 24; month := 3; -- March END IF; -- Return the date of Easter Sunday for the given year RETURN TO_DATE(TO_CHAR(year, 'YYYY') || '-' || LPAD(month, 2, '0') || '-' || LPAD(day, 2, '0'), 'YYYY-MM-DD'); */ /* The DIV functions are not PL/SQL, and the rest of the calculation is never going to work... */ return null; exception when others then raise_application_error(-20001, 'Invalid year. Year must be a positive integer.'); end; -- function google_gemma_3_4b_q4_k_m(in_year in pls_integer) return date deterministic as -- Added DETERMINISTIC for better performance and predictability year number; a number; b number; c number; d number; e number; f number; g number; h number; i number; begin /* -- Get the current year year := TRUNC(SYSDATE); -- Calculate Easter date using the algorithm a := year; b := a % 4; c := a % 100; d := a % 400; e := (19 * a) / 330; f := (5 * a) / 16; g := (a + 12) / 365.25; h := (a + 12) % 365.25; i := e + f + g + h; -- Calculate the day of Easter Sunday based on the calculated date RETURN DATE '2000-03-28' + i - 7; -- Adjust for March 28th as a reference point */ /* The code won't run, so I commented it out; there are quite a few problems here: A YEAR input parameter was missing, so I added one. The first line (FUNCTION...) was misshapen (I fixed it to get the package to compile) and the fourth line was DECLARE, which is nonsense. Invalid: "b := a % 4;" - I assume it means "b = mod(a, 4)". Invalid: "year := TRUNC(SYSDATE)" - I assume it means "year := extract(year from SYSDATE)". Invalid: "RETURN DATE '2000-03-28' + i - 7" - I assume it means "RETURN to_date('2000-03-28','YYYY-MM-DD') + i - 7" With those fixes in place, the result for 2026 would November 13th 2002... Apart from the coding errors, the calculation itself seems way too simple compared to the correct one(s). But this is a very small model, so this was to be expected. */ return null; end; -- function google_gemma_3n_e4b_q8_0(p_year in number) return date is l_a number; l_b number; l_c number; l_d number; l_e number; l_f number; l_g number; l_h number; l_i number; l_k number; l_l number; l_m number; l_day number; l_month number; begin -- Validate input year (optional, adjust range as needed) if p_year < 1583 then raise_application_error(-20001, 'Algorithm valid only for years >= 1583 (Gregorian calendar).'); end if; -- Meeus/Jones/Butcher algorithm (Gregorian calendar) l_a := mod(p_year, 19); l_b := floor(p_year / 100); l_c := mod(p_year, 100); l_d := floor(l_b / 4); l_e := mod(l_b, 4); l_f := floor((l_b + 8) / 25); l_g := floor((l_b - l_f + 1) / 3); l_h := mod(19 * l_a + l_b - l_d - l_g + 15, 30); -- Correction for certain moon calculations: if l_h = 29 or (l_h = 28 and l_a > 11) then l_h := l_h - 1; end if; l_i := floor(l_c / 4); l_k := mod(l_c, 4); l_l := mod(32 + 2 * l_e + 2 * l_i - l_h - l_k, 7); l_m := floor((l_a + 11 * l_h + 22 * l_l) / 451); -- Compute month and day l_month := floor((l_h + l_l - 7 * l_m + 114) / 31); l_day := mod(l_h + l_l - 7 * l_m + 114, 31) + 1; -- # ORIGINAL: RETURN TO_DATE(p_year || '-' || TO_CHAR(l_month, '01') || '-' || TO_CHAR(l_day, '01'), 'YYYY-MM-DD'); return to_date(p_year || '-' || to_char(l_month, '00') || '-' || to_char(l_day, '00'), 'YYYY-MM-DD'); /* Apart from the TO_CHAR '01' issue I fixed above, this works great. Note that there is a check to validate "year >= 1538", but no "year <= 4909". */ end; -- function google_gemma_4_26b_a4b_q4_k_m(p_year in number) return date is /* Algorithm: Meeus/Butcher Algorithm This algorithm calculates the month and day of Easter Sunday based on the lunar cycle and solar calendar adjustments. */ v_a number; -- Year mod 19 v_b number; -- Floor(year / 100) v_c number; -- Year mod 100 (not strictly needed for calculation, but part of the cycle) v_d number; -- Floor(b / 4) v_e number; -- b mod 4 v_f number; -- (b + 2) mod 7 v_g number; -- (19a + b - d - f + 15) mod 30 v_h number; -- 5 - g v_i number; -- (year + 2 - g) mod 7 v_j number; -- (19a + b - d - h + 15) mod 30 v_month number; v_day number; begin -- 1. Basic cycle calculations v_a := mod(p_year, 19); v_b := floor(p_year / 100); v_c := mod(p_year, 100); v_d := floor(v_b / 4); v_e := mod(v_b, 4); v_f := mod((v_b + 2), 7); -- 2. Calculate the lunar/solar offset (g) v_g := mod((19 * v_a + v_b - v_d - v_f + 15), 30); -- 3. Determine secondary adjustments (h and i) v_h := 5 - v_g; v_i := mod((p_year + 2 - v_g), 7); -- 4. Calculate the month (j) -- In this algorithm, j represents the calculation for the specific month index v_j := mod((19 * v_a + v_b - v_d - v_h + 15), 30); /* In the Butcher algorithm, we use the values of g, h, and i to determine if Easter falls in March or April. */ -- Calculate the day offset from March 22nd v_day := 22 + v_g; -- Check for overflow into April if v_day > 31 then v_month := 4; v_day := v_day - 31; else v_month := 3; end if; -- Return the formatted date return to_date(v_day || '-' || v_month || '-' || p_year, 'DD-MM-YYYY'); /* This took a long time to generate, and require a token increase, but it did compile. The results are not great however. Note that there is no check to validate the year. */ exception when others then raise_application_error(-20001, 'Error calculating Easter date: ' || sqlerrm); end; -- function google_gemma_4_e4b_q8_0(p_year in number) return date is -- Variables derived from the calculation algorithm a number; b number; c number; d number; e number; f number; g number; h number; i number; k number; l number; -- # ADDED m number; -- # ADDED begin -- Input validation if p_year is null or p_year < 1583 then -- The Gregorian calendar rules are generally applied from this point onward for consistency. raise_application_error(-20001, 'Invalid year provided. Please enter a year >= 1583.'); end if; -- --- Easter Calculation Algorithm (Based on Meeus/Astronomical Rules) --- a := p_year mod 19; b := floor(p_year / 100); c := p_year mod 100; d := floor(b / 4); e := b mod 4; f := floor((b + 8) / 25); g := floor((b - f + 1) / 3); h := (19 * a + b - d - g + 15) mod 30; i := floor(c / 4); k := c mod 4; -- Adjustments for the date calculation l := (32 + 2 * e + 2 * i - h - k) mod 7; m := floor((a + 11 * l + 22) / 451); -- Correction factor for rare cases -- Calculate the final date components d := 22 + (h + l - 7 * m); -- Handle potential overflow if the calculated day is greater than 31 (shouldn't happen with this algorithm, but good practice) if d > 31 then d := d - 31; -- # ORIGINAL: p_year := p_year + 1; m := m + 1; end if; -- Return the final date object (Month is always April or March) if d <= 31 and h + l < 10 then -- If the calculated day falls in March (i.e., if the result was > 31, we adjusted year/day above) -- # ORIGINAL: RETURN TO_DATE(p_year || '03' || LPAD(d, 2, '0'), 'YYYYMMDD'); return to_date(p_year || '03' || lpad(d, 2, '0'), 'YYYYMMDD'); else -- The date is in April -- # ORIGINAL: RETURN TO_DATE(p_year || '04' || LPAD(d, 2, '0'), 'YYYYMMDD'); return to_date(p_year || '04' || lpad(d, 2, '0'), 'YYYYMMDD'); end if; /* Variables l and m were not declare, so I added them. Also it was trying to add 1 to p_year, which is of course not allowed - and also wrong, it should have added 1 to m. After that it worked, and the results are great. Note that there is a check to validate "year >= 1538", but no "year <= 4909". */ exception when others then -- Re-raise the error if it wasn't our custom validation error raise; end; -- function mistralai_devstral_small_2_2512_f16(p_year in number) return date is a number; b number; c number; d number; e number; f number; g number; h number; i number; k number; l number; m number; begin -- Gaussian algorithm for calculating Easter Sunday a := p_year mod 19; b := floor(p_year / 100); c := p_year mod 100; d := floor(b / 4); e := b mod 4; f := floor((b + 8) / 25); g := floor((b - f + 1) / 3); h := (19 * a + b - d - g + 15) mod 30; i := c; i := floor(c / 4); k := c mod 4; l := (32 + 2 * e + 2 * i - h - k) mod 7; m := floor((a + 11 * h + 22 * l) / 451); /* -- Calculate the month and day IF (h + l - 7 * m + 114) <= 0 THEN RETURN TO_DATE('03/' || (h + l - 7 * m + 114 + 31) || '/' || p_year, 'DD/MM/YYYY'); ELSE RETURN TO_DATE((h + l - 7 * m + 114) || '/04/' || p_year, 'DD/MM/YYYY'); END IF; */ /* The calculations done in the IF statement are never going to work; the calculated day or month are way too big. Also in the ELSE section the day and month seem to be reversed in the TO_DATE. */ return null; end; -- function mistralai_devstral_small_2_2512_q3_k_l(p_year in number) return date is -- Function to calculate Easter Sunday date using the Gaussian algorithm -- Returns NULL if p_year is not between 1583 and 4909 (Gregorian calendar range) begin -- Validate input year range if p_year < 1583 or p_year > 4909 then return null; end if; -- Gaussian algorithm calculations declare a number := p_year mod 19; b number := floor(p_year / 100); c number := p_year mod 100; d number := floor(b / 3); e number := floor(11 * a + 20) mod 30; f number := floor(c / 4); g number := floor((b + 8) / 25); h number := floor((b - g + 1) / 3); i number := ((a + 11 * e + 22 * d) mod 4) + b; j number := floor(c / 4); k number := ((3 * e + c - i) mod 7) + 28; m number := floor((b - g + 1) / 3); n number := (i + k) mod 31; begin -- Return the calculated date (March or April) return to_date('03-' || lpad(to_char(n), 2, '0') || '-' || p_year, 'MM-DD-YYYY'); end; /* The code runs, and the result is close, but incorrect: March 22nd 2026. Note that March is hardcoded, although April is mentioned as a possibility in the comment. */ end; -- function qwen_qwen3_coder_next_q4_k_m(p_year in pls_integer) return date is l_a pls_integer; l_b pls_integer; l_c pls_integer; l_d pls_integer; l_e pls_integer; l_f pls_integer; l_g pls_integer; l_h pls_integer; l_i pls_integer; l_k pls_integer; l_l pls_integer; l_m pls_integer; l_day pls_integer; l_month pls_integer; begin -- Validate input year (optional; adjust range as needed) if p_year < 1583 then raise_application_error(-20001, 'Algorithm valid only for years >= 1583 (Gregorian calendar).'); end if; -- Meeus/Jones/Butcher algorithm (Gregorian calendar) l_a := mod(p_year, 19); l_b := floor(p_year / 100); l_c := mod(p_year, 100); l_d := floor(l_b / 4); l_e := mod(l_b, 4); l_f := floor((l_b + 8) / 25); l_g := floor((l_b - l_f + 1) / 3); l_h := mod(19 * l_a + l_b - l_d - l_g + 15, 30); -- Correction for certain moon calculations: if l_h = 29 or (l_h = 28 and l_a > 11) then l_h := l_h - 1; end if; l_i := floor(l_c / 4); l_k := mod(l_c, 4); l_l := mod(32 + 2 * l_e + 2 * l_i - l_h - l_k, 7); l_m := floor((l_a + 11 * l_h + 22 * l_l) / 451); -- Compute month and day l_month := floor((l_h + l_l - 7 * l_m + 114) / 31); l_day := mod(l_h + l_l - 7 * l_m + 114, 31) + 1; -- # ORIGINAL: RETURN MAKE_DATE(p_year, l_month, l_day); return to_date(p_year || to_char(l_month, 'fm00') || to_char(l_day, 'fm00'), 'YYYYMMDD'); /* Obviously MAKE_DATE is not a valid function, so I fixed that - but apart from that is works great. Note that there is a check to validate "year >= 1538", but no "year <= 4909". */ end; -- function qwen_qwen3_5_35b_a3b_q4_k_m(p_year number) return date is -- Variables for the computus algorithm a number; b number; c number; d number; e number; f number; g number; h number; i number; j number; k number; l number; -- Result month and day easter_month number := 3; easter_day number := 25; begin -- Validate input year if p_year < 1583 then raise_application_error(-20001, 'Year must be >= 1583 (Gregorian calendar)'); end if; a := mod(p_year, 19); b := floor(p_year / 100); c := mod(p_year, 100); d := floor(b / 4); e := mod(b, 4); f := floor((b + 8) / 25); g := floor((b - f + 1) / 3); h := mod(19 * a + b - d - g + 15, 30); i := mod(c, 4); k := mod(h / 28, 1); if (k = 1 or k = 0) and h = 29 then l := 29; else l := mod(7 * (i + floor((h + d - l) / 3)) + floor(p_year / 4), 7); end if; easter_month := mod(h + l + 114, 31); easter_day := floor((h + l + 114) / 31); -- Return the date /* RETURN TO_DATE(TO_CHAR(easter_month) || '/' || TO_CHAR(easter_day) || '/' || TO_CHAR(p_year), 'MM/DD/YYYY'); */ /* I commented out the RETURN, because in "l := MOD(7 * (i + FLOOR((h + d - l) / 3)) + FLOOR(p_year / 4), 7);" variable l is referenced in the calculation while it is still null; so all calculations after that return null as well - and the TO_DATE in the RETURN would create an error. Too bad, because the code itself looks promising. */ return null; exception when others then raise_application_error(-20002, 'Error calculating Easter: ' || sqlerrm); end; -- function qwen_qwen3_5_35b_a3b_q8_0(p_year in number) return date is a number; b number; c number; d number; e number; f number; g number; h number; i number; j number; k number; l number; m number; n number; begin -- Validate input year if p_year < 1583 then raise_application_error(-20001, 'Year must be 1583 or later (Gregorian calendar)'); end if; a := mod(p_year, 19); b := floor(15 * p_year / 4); c := floor((b - 16) / 4); d := mod(floor(b + 8) / 25, 30); e := mod(d / 5, 3); f := floor(9 * p_year / 4); g := floor((f - c) / 3); h := mod(a * (19 + d - e) - g, 30); i := floor(h / 28); j := mod(i, 3); -- Adjust for special cases in the algorithm if h = 29 and j = 6 then l := 1; else l := mod(floor(7 * (h + 1) - i), 7); end if; m := floor(p_year / 400) - floor(p_year / 100) + floor(p_year / 4); n := 20 + h - l; -- Check if Easter falls in April or March /* IF n < 32 THEN RETURN TO_DATE(TO_CHAR(p_year) || '-03-' || LPAD(n, 2, '0'), 'YYYY-MM-DD'); ELSE RETURN TO_DATE(TO_CHAR(p_year) || '-04-' || LPAD(n - 31, 2, '0'), 'YYYY-MM-DD'); END IF; */ /* I commented out the last IF statement, because e.g. for 2026, n equals 5.32, so the TO_DATE fails. If I force n to be an integer using floor(), the result is March 5th 2026. Close but no cigar. Also note that m is calculated but never used after that. */ return null; exception when others then raise_application_error(-20002, 'Error calculating Easter Sunday: ' || sqlerrm); end; -- function zai_org_glm_4_7_flash_q8_0(in_year in pls_integer) return date is begin /* Watching it come up with all sorts of solutions, and then rejecting them, correcting itself, and trying again, over and over, was fun - but also a bit creepy... But more importantly, it got itself stuck in a loop, generate the same lines of reasoning over and over again, not getting any closer to a solution. So after about 15 minutes I decided to put it out of its misery. */ return null; end; -- function openai_gpt_oss_20b_mxfp4(p_year in number) return date is -- The following variables are used only inside the algorithm. a constant number := p_year mod 19; -- (a) Golden Year b constant number := floor(p_year / 100); -- (b) Century c constant number := p_year mod 100; -- (c) Year within century d constant number := floor(b / 4); -- (d) Leap year in the century e constant number := b mod 4; -- (e) Unused remainder of leap f constant number := floor((b + 8) / 25); -- (f) Correction factor g constant number := floor((b - f + 1) / 3); -- (g) Another correction h constant number := (19 * a + b - d - g + 15) mod 30; -- (h) Metonic cycle i constant number := floor(c / 4); -- (i) Leap year in the year k constant number := c mod 4; -- (k) Unused remainder of leap l constant number := (32 + 2 * e + 2 * i - h - k) mod 7; -- (l) Day offset m constant number := floor((a + 11 * h + 22 * l) / 451); -- (m) Exception for 1900-2099 month number; day number; begin -- Month (3 = March, 4 = April) month := floor((h + l - 7 * m + 114) / 31); -- Day of the month day := mod(h + l - 7 * m + 114, 31) + 1; return to_date(day || '-' || month || '-' || p_year, 'DD-MM-YYYY'); /* This worked flawlessly out of the box. Variables A through M do not need to be constants, and there is no check to validate the year, but apart from that: perfect. */ end; -- -- My own function(s) needed for the page: function get_easter ( in_model_name in varchar2 ,in_variant in varchar2 ,in_year in pls_integer ) return date deterministic is l_return date; e_unknown_model exception; l_unknown_date date := to_date('01-01-9999', 'DD-MM-YYYY'); begin l_return := (case in_model_name || '_' || in_variant when 'essentialai/rnj-1_Q8_0' then ted_p1199.essentialai_rnj_1_q8_0(in_year) when 'google/gemma-3-12b_Q8_0' then ted_p1199.google_gemma_3_12b_q8_0(in_year) when 'google/gemma-3-27b_Q4_0' then ted_p1199.google_gemma_3_27b_q4_0(in_year) when 'google/gemma-3-4b_Q4_K_M' then ted_p1199.google_gemma_3_4b_q4_k_m(in_year) when 'google/gemma-3n-e4b_Q8_0' then ted_p1199.google_gemma_3n_e4b_q8_0(in_year) when 'google/gemma-4-26b-a4b_Q4_K_M' then ted_p1199.google_gemma_4_26b_a4b_q4_k_m(in_year) when 'google/gemma-4-e4b_Q8_0' then ted_p1199.google_gemma_4_e4b_q8_0(in_year) when 'mistralai/devstral-small-2-2512_Q3_K_L' then ted_p1199.mistralai_devstral_small_2_2512_q3_k_l(in_year) when 'mistralai/devstral-small-2-2512_F16' then ted_p1199.mistralai_devstral_small_2_2512_f16(in_year) when 'openai/gpt-oss-20b_MXFP4' then ted_p1199.openai_gpt_oss_20b_mxfp4(in_year) when 'qwen/qwen3-coder-next_Q4_K_M' then ted_p1199.qwen_qwen3_coder_next_q4_k_m(in_year) when 'qwen/qwen3.5-35b-a3b_Q4_K_M' then ted_p1199.qwen_qwen3_5_35b_a3b_q4_k_m(in_year) when 'qwen/qwen3.5-35b-a3b_Q8_0' then ted_p1199.qwen_qwen3_5_35b_a3b_q8_0(in_year) when 'zai-org/glm-4.7-flash_Q8_0' then ted_p1199.zai_org_glm_4_7_flash_q8_0(in_year) else l_unknown_date end); if l_return = l_unknown_date then raise e_unknown_model; end if; return l_return; exception when e_unknown_model then raise_application_error(-20000, 'Unknown model: ' || in_model_name || '_' || in_variant); when others then raise_application_error(-20000, 'Model: ' || in_model_name || '_' || in_variant || ', Year: ' || in_year || ', Error: ' || sqlerrm); end get_easter; end ted_p1199;