In `@contrib/ivorysql_ora/expected/utl_file.out`:
- Around line 103-106: The test's expected output hardcodes "block_size = 4096"
which is filesystem-dependent; update the expected result handling for the
utl_file test so it no longer asserts a specific block_size: either mask or
wildcard the block_size token in contrib/ivorysql_ora/expected/utl_file.out
(e.g., replace the numeric value with a placeholder or regex) or remove the
block_size field from the NOTICE lines, and/or add a comment documenting the
filesystem assumption; locate occurrences of "block_size =" and "fexists" in the
expected output to make the change.

In `@contrib/ivorysql_ora/sql/utl_file.sql`:
- Around line 1-165: The test file omits coverage for new APIs fopen_nchar,
put_line_nchar, get_line_nchar, and put_raw and doesn't remove generated files;
add small positive-path cases that open a file via
utl_file.fopen_nchar('data_directory', 'regress_nchar.txt', 'w'), write with
utl_file.put_line_nchar and utl_file.put_raw, close, then reopen with
utl_file.fopen_nchar(...,'r') and read back using utl_file.get_line_nchar to
assert content, and finally remove created files with
utl_file.fremove('data_directory', 'regress.txt'),
utl_file.fremove('data_directory', 'regress2.txt'),
utl_file.fremove('data_directory', 'regressflush.txt'), and the new
regress_nchar.txt to ensure cleanup.

In `@contrib/ivorysql_ora/src/builtin_packages/utl_file/utl_file--1.0.sql`:
- Around line 168-171: The SQL-language wrapper for sys.ora_utl_file_put_line
incorrectly references the parameter by name ("autoflush") instead of position;
update the function body to use positional parameters so the third argument is
$3 (e.g., call sys.ora_utl_file_put_line($1, $2::text, $3)); adjust only the SQL
function AS $$...$$ to replace the bare identifier "autoflush" with $3 so the
parameters match the signature.
- Around line 60-66: The composite type sys.ora_utl_file_fgetattr_result
declares file_length as integer (32-bit) but the C function
sys.ora_utl_file_fgetattr returns a 64-bit value (Int64GetDatum); update the
composite type so file_length is bigint (or int8) to match the C return and
avoid overflow for files >2GB, leaving fexists and block_size unchanged; ensure
the SQL CREATE TYPE line for sys.ora_utl_file_fgetattr_result is modified
accordingly.
- Around line 173-176: The C implementation of ora_utl_file_put_raw is ignoring
the third parameter (autoflush) declared in the SQL wrapper; update the
implementation in utl_file.c (function ora_utl_file_put_raw) to fetch the third
argument (autoflush) and, when true, perform a flush/sync on the file after
writing (mirror existing flush logic used by other put/close functions), or
alternatively update the SQL declaration to remove/document the unused
parameter; prefer changing ora_utl_file_put_raw to read the boolean arg and call
the appropriate flush function after the write so callers using autoflush =>
true actually get a flush.

In `@contrib/ivorysql_ora/src/builtin_packages/utl_file/utl_file.c`:
- Around line 687-698: ora_utl_file_ftell currently calls ftell(fd) (which
returns long) and returns it via PG_RETURN_INT32 causing silent truncation for
offsets > INT32_MAX; update ora_utl_file_ftell to capture the ftell() result
into a long (or off_t) variable, check for errors (ftell == -1L) and for
overflow beyond INT32_MAX/INT32_MIN, and if overflow or error occur raise an
error (or alternatively return a 64-bit PG type using PG_RETURN_INT64 if
compatible with the API), ensuring you still call CHECK_FILE_HANDLE(),
get_file_handle_from_slot(), and use INVALID_FILEHANDLE_EXCEPTION() as before.
- Around line 1406-1409: The string passed to GUC_check_errdetail in the digits
> 3 branch is missing a closing parenthesis; update the error message string in
that conditional (the GUC_check_errdetail(...) call) to read "number is too big
(only four digits are allowed)" so the parentheses are balanced and the message
is correct.
- Around line 425-444: The ora_utl_file_fclose function is using PG_GETARG_INT32
to retrieve a slot ID although slot IDs are uint32; replace the arg retrieval
with PG_GETARG_UINT32(0) so you call free_slot with the correct unsigned slot ID
(i.e., change free_slot(PG_GETARG_INT32(0)) to free_slot(PG_GETARG_UINT32(0))).
Keep the rest of the error handling (EBADF/STRERROR_EXCEPTION) unchanged; this
aligns ora_utl_file_fclose with fopen/fflush/fseek which use
PG_RETURN_UINT32/PG_GETARG_UINT32.
- Around line 1227-1249: The function get_file_handle_from_slot can return NULL
on a stale slot (it currently calls INVALID_FILEHANDLE_WARNING() and returns
NULL), leading to callers like ora_utl_file_fflush, ora_utl_file_get_line,
ora_utl_file_new_line, ora_utl_file_putf, do_put (and transitive
ora_utl_file_put, ora_utl_file_put_line), and ora_utl_file_put_raw invoking
stdio functions on NULL; change the behavior so a missing slot triggers an
error/exception instead of just a warning—replace the
INVALID_FILEHANDLE_WARNING() path with the same error path used for
INVALID_SLOTID (e.g., call INVALID_FILEHANDLE_EXCEPTION() or otherwise raise an
error before returning) so get_file_handle_from_slot never returns NULL and
callers need not be changed.
- Around line 1050-1090: In close_all_files(), the loop can overwrite errno
across iterations so STRERROR_EXCEPTION(WRITE_ERROR) may report a stale or
incorrect error; modify close_all_files to record the first failing errno (e.g.,
add an int first_errno = 0), on each fclose failure if first_errno == 0 set
first_errno = errno and set report_error = true, and after the loop pass that
saved errno into the error-reporting path (use strerror(first_errno) or
otherwise ensure STRERROR_EXCEPTION uses that saved value) while still cleaning
up slots and closing other fds; reference symbols: close_all_files, slots[], fd,
fclose, report_error, STRERROR_EXCEPTION(WRITE_ERROR), errno.
- Around line 196-231: reserve_slot currently calls NEXT_SLOTID(slotid) but
never updates the global slotid on wrap, so after UINT32_MAX all new slots get
id 1; fix by updating slotid and using the updated value when assigning
slots[i].id — e.g., compute the new id into slotid (slotid =
NEXT_SLOTID(slotid)) and then set slots[i].id = slotid (or change NEXT_SLOTID to
assign back to its argument), referencing NEXT_SLOTID, slotid, reserve_slot and
slots[i].id to locate the change.
- Around line 663-685: The implementation of ora_utl_file_fseek incorrectly sums
absolute and relative offsets and always seeks from SEEK_SET; change it to
follow Oracle semantics: if the absolute_offset argument is not null (check
PG_ARGISNULL(1) / use the same presence check used elsewhere) call fseek(fd,
absolute_offset, SEEK_SET); else if the relative_offset argument is not null
call fseek(fd, relative_offset, SEEK_CUR); if both are null simply return
without seeking; keep the existing error path (raise INVALID_OFFSET via
CUSTOM_EXCEPTION when fseek returns non-zero) and preserve use of
get_file_handle_from_slot/CHECK_FILE_HANDLE/INVALID_FILEHANDLE_EXCEPTION for
locating fd.
- Around line 500-524: In fcopy, when copy_text_file(srcfile, dstfile,
start_line, end_line) returns non-zero you must close both raw FILE* handles
before raising the IO_EXCEPTION to avoid leaking srcfile and dstfile; update the
error path in the fcopy function to call fclose(srcfile) and fclose(dstfile) (or
use a PG_TRY/PG_CATCH around the operation and ensure fclose is called in the
cleanup/exception path) prior to invoking IO_EXCEPTION so both handles are
always closed on error.
- Around line 1095-1135: In copy_text_file, the do/while loops assume each
fgets() read ends with '\n' and treat fgets()==NULL as an error (returning
errno), which drops or prematurely stops copying a final line without a trailing
newline; update both the skip and copy loops inside copy_text_file to check if
fgets() returns NULL: for the skip loop, break out of the inner loop (and outer
skip loop) when fgets()==NULL (EOF) instead of returning errno; for the copy
loop, if fgets()==NULL write any partial buffer content already read (ensure
len>0 before accessing buffer[len-1]) and then break to finish normally
returning 0 rather than returning errno; keep references to buffer, fgets,
fwrite, start_line and end_line when locating the change.
- Around line 1001-1048: get_safe_path currently skips locality validation when
safe_named_location() returns a mapped directory (variable location); after
canonicalize_path(fullname) you must ensure the canonicalized fullname actually
stays under that resolved location: canonicalize and store the resolved location
string (location) as an absolute path and then verify fullname starts with that
resolved location plus a path separator (or equals it); if not, throw the
appropriate error/raise exception (same semantics as check_secure_locality)
instead of returning the path; retain the existing behavior of calling
check_secure_locality(fullname) when location is NULL.
- Around line 861-873: ora_utl_file_put_raw currently calls do_write which
performs text encoding conversion (via encode_text/pg_do_encoding_conversion)
and will corrupt binary bytea data; change ora_utl_file_put_raw to bypass
do_write and instead extract the raw byte buffer and length from the bytea
argument using VARDATA_ANY and VARSIZE_ANY_EXHDR, then call fwrite to write that
exact byte buffer to the FILE* returned by get_file_handle_from_slot (keep
existing CHECK_FILE_HANDLE and NOT_NULL_ARG checks), check fwrite result for
short/failed writes and report errors similarly to other file ops; remove any
encoding conversion references (encode_text/pg_do_encoding_conversion) from this
path so raw bytes are written unchanged.