Using utl_file and unix pipes

Question

Hi,
I'm trying to use utl_file and unix pipes to communicate with a unix process.
Basically I want the unix process to read off one pipe and give me back the result on a different pipe.
In the example below the unix process is a dummy one just copying the input to the output.
I cant get this to work for a single plsql block writing and reading to/from the pipes - it hangs on the first read of the return pipe.
Any ideas?
======== TEST CASE 1 ===============
create directory tmp as '/tmp';
on unix:
cd /tmp
mknod outpip p
mknod inpip p
cat < inpip > outpip
drop table res;
create table res (m varchar2(200));
declare
l_filehandle_rec UTL_FILE.file_type;
l_filehandle_send UTL_FILE.file_type;
l_char VARCHAR2(200);
begin
insert into res values ('starting');commit;
l_filehandle_send := UTL_FILE.fopen ('TMP', 'inpip', 'A', 32000);
insert into res values ('opened inpip ');commit;
l_filehandle_rec := UTL_FILE.fopen ('TMP', 'outpip', 'R', 32000);
insert into res values ('opened outpip ');commit;
FOR i in 1..10 LOOP
utl_file.put_line(l_filehandle_send,'line '||i);
insert into res values ('written line '||i); commit;
utl_file.get_line(l_filehandle_rec,l_char);
insert into res values ('Read '||l_char);commit;
END LOOP;
utl_file.fclose(l_filehandle_send);
utl_file.fclose(l_filehandle_rec);
END;
in a different sql session:
select * from res:
starting
opened inpip
opened outpip
written line 1
============ TEST CASE 2 =================
However If I use 2 different sql session (not what I want to do...), it works fine:
1. unix start cat < inpip > outpip
2. SQL session 1:
set serveroutput on size 100000
declare
l_filehandle UTL_FILE.file_type;
l_char VARCHAR2(200);
begin
l_filehandle := UTL_FILE.fopen ('TMP', 'outpip', 'R', 32000);
FOR i in 1..10 LOOP
utl_file.get_line(l_filehandle,l_char);
dbms_output.put_line('Read '||l_char);
END LOOP;
utl_file.fclose(l_filehandle);
END;
3. SQL session 2:
set serveroutput on size 100000
declare
l_filehandle UTL_FILE.file_type;
begin
l_filehandle := UTL_FILE.fopen ('TMP', 'inpip', 'A', 32000);
FOR i in 1..10 LOOP
utl_file.put_line(l_filehandle,'line '||i);
--utl_lock.sleep(1);
dbms_output.put_line('written line '||i);
END LOOP;
utl_file.fclose(l_filehandle);
END;
/

Answer 1

> it hangs on the first read of the return pipe.
Correct.
A pipe is serialised I/O device. One process writes to the pipe. The write is blocked until a read (from another process or thread) is made on that pipe. Only when there is a reader for that data, the writer is unblocked and the actual write I/O occurs.
The reverse is also true. A read on the pipe is blocked until another process/thread writes data into the pipe.
Why? A pipe is a memory structure - not a file system file. If the write was not blocked the writer process can writes GBs of data into the pipe before a reader process starts to read that data. This will drastically knock memory consumption and performance.
Thus the purpose of a pipe is to serve as a serialised blocking mechanism between a reader and a writer - allowing one to write data that is read by the other. With minimal memory overheads as the read must be serviced by a write and a write serviced by a read.
If you're looking for something different, then you can open a standard file in share mode and write and read from it using two different file handles within the same process. However, the file will obviously have a file system footprint ito space (growing until the writer stops and the reader terminates and trashes the file) .
OTOH a pipe's footprint is minimal.