Oracle. Cannot pass blob >=32 768 bytes as stored procedure parameter

DataParameter a_data = new DataParameter("a_data", new byte[32768], DataType.Blob);
a_data.Size = alert.alert.photo.content.Length;
dataConnection.ExecuteProc("ProcedureName", new[] {  a_data });

ORA-01460: unimplemented or unreasonable conversion requested blob insert

Following code works:

var cmd = new OracleCommand("declare xx blob; begin dbms_lob.createtemporary(xx, false, 0); :tempblob := xx; end;");
cmd.Connection = (OracleConnection)dataConnection.Connection;

var param = new OracleParameter("tempblob", OracleDbType.Blob) { Direction = ParameterDirection.Output };
cmd.Parameters.Add(param);

cmd.ExecuteNonQuery();

var tempLob = (OracleBlob)param.Value;
tempLob.Write(new byte[32768], 0, 32768);

var comm = dataConnection.Connection.CreateCommand();
comm.CommandText = "ProcedureName";
comm.CommandType = CommandType.StoredProcedure;

var a_data = new OracleParameter("a_data", OracleDbType.Blob) { Value = tempLob };
comm.Parameters.Add(a_data );

comm.ExecuteNonQuery();

[mrcopperbeard]

Found a workaround by specifying dbType as “BLOB” explicitly via constructor

new DataParameter("a_data", tempLob, "BLOB")

Many thanks to fellows from EF Core 😉

Update: Figured out that we can’t pass null this way. Thats why workaround became more tricky

var foo = tempLob == null
    ? DataParameter.Blob("a_data", tempLob)
    : new DataParameter("a_data", tempLob, "BLOB")

[jods4]

Yes, there is another Github issue about having a true, generic, stream support. Disposal is a big issue and differences between dbs as well: when writing Oracle works in push fashion (you write into OracleBlob first); SqlServer works in a pull fashion (you pass a stream that is read by the sql provider).

In the meantime the ability to work with native DB types (e.g. OracleBlob) is a good enough stop-gap.

I found out that if you type your model property as OracleBlob you can read without problems:

class Frob
{
  public int Id { get; set }
  public OracleBlob Data { get; set; }
}

var row = db.Frobs.First(x => x.Id == 3);
// This is a perfectly usable OracleBlob that you can read as a stream.
var blob = row.Data;
// Don't forget to dispose.

But strangely something fishy happens if you try to write:

var frob = new Frob { Id = 1, Data = new OracleBlob(...) };
// Write into the blob
frob.Data.Write(...);
// Try to insert
db.Frobs.Insert(frob);
// Works, but not as you'd expect....

This write seems to work but as was observed in this issue, it also seems that the OracleBlob isn’t passed directly as a parameter value but rather is converted into a byte array. For instance, every byte is logged in the trace (should not be possible) and the OP here observed that values larger than 32k don’t go through (they should when using OracleBlob).

It’s probably just a small issue but if it worked it would unlock writing large blobs with Linq2Db.