internal BlobStream(sqlite3_blob blob, SQLiteDatabaseConnection db, bool canWrite, int length)
{
this.blob = blob;
this.db = db;
this.canWrite = canWrite;
this.length = length;
this.dbDisposing = (o, e) => this.Dispose(true);
this.db.Disposing += dbDisposing;
}
/*
** Open a blob handle.
*/
int sqlite3_blob_open(
sqlite3* db, /* The database connection */
string zDb, /* The attached database containing the blob */
string zTable, /* The table containing the blob */
string zColumn, /* The column containing the blob */
sqlite_int64 iRow, /* The row containing the glob */
int flags, /* True -> read/write access, false -> read-only */
sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
){
int nAttempt = 0;
int iCol; /* Index of zColumn in row-record */
public void test_blob_write_with_byte_array_offset()
{
using (sqlite3 db = ugly.open(":memory:"))
{
const int len = 100;
db.exec("CREATE TABLE foo (b blob);");
db.exec("INSERT INTO foo (b) VALUES (zeroblob(?))", len);
long rowid = db.last_insert_rowid();
byte[] blob = db.query_scalar <byte[]>("SELECT b FROM foo;");
Assert.AreEqual(blob.Length, len);
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(blob[i], 0);
}
using (sqlite3_blob bh = db.blob_open("main", "foo", "b", rowid, 1))
{
int len2 = bh.bytes();
Assert.AreEqual(len, len2);
byte[] blob2 = new byte[len];
for (int i = 0; i < 100; i++)
{
blob2[i] = 73;
}
bh.write(blob2, 40, 20, 50);
}
byte[] blob3 = db.query_scalar <byte[]>("SELECT b FROM foo;");
Assert.AreEqual(blob3.Length, len);
for (int i = 0; i < 50; i++)
{
Assert.AreEqual(blob3[i], 0);
}
for (int i = 50; i < 70; i++)
{
Assert.AreEqual(blob3[i], 73);
}
for (int i = 70; i < 100; i++)
{
Assert.AreEqual(blob3[i], 0);
}
}
}
private Stream ReadBlobIntoPooledStream(sqlite3_blob blob, int length)
{
var bytes = SQLitePersistentStorage.GetPooledBytes();
try
{
ThrowIfNotOk(raw.sqlite3_blob_read(blob, bytes, length, offset: 0));
// Copy those bytes into a pooled stream
return(SerializableBytes.CreateReadableStream(bytes, length));
}
finally
{
// Return our small array back to the pool.
SQLitePersistentStorage.ReturnPooledBytes(bytes);
}
}
private Stream ReadBlob(sqlite3_blob blob)
{
var length = raw.sqlite3_blob_bytes(blob);
// If it's a small blob, just read it into one of our pooled arrays, and then
// create a PooledStream over it.
if (length <= SQLitePersistentStorage.MaxPooledByteArrayLength)
{
return(ReadBlobIntoPooledStream(blob, length));
}
else
{
// Otherwise, it's a large stream. Just take the hit of allocating.
var bytes = new byte[length];
ThrowIfNotOk(raw.sqlite3_blob_read(blob, bytes, length, offset: 0));
return(new MemoryStream(bytes));
}
}
public void test_blob_write()
{
using (sqlite3 db = ugly.open(":memory:"))
{
const int len = 100;
db.exec("CREATE TABLE foo (b blob);");
using (sqlite3_stmt stmt = db.prepare("INSERT INTO foo (b) VALUES (?)"))
{
stmt.bind_zeroblob(1, len);
stmt.step();
}
long rowid = db.last_insert_rowid();
using (sqlite3_blob bh = db.blob_open("main", "foo", "b", rowid, 1))
{
int len2 = bh.bytes();
Assert.AreEqual(len, len2);
int passes = 10;
Assert.AreEqual(len % passes, 0);
int sublen = len / passes;
byte[] buf = new byte[sublen];
for (int i = 0; i < sublen; i++)
{
buf[i] = (byte)(i % 256);
}
for (int q = 0; q < passes; q++)
{
bh.write(buf, q * sublen);
}
}
}
}
public void test_blob_read()
{
using (sqlite3 db = ugly.open(":memory:"))
{
const int len = 100;
db.exec("CREATE TABLE foo (b blob);");
db.exec("INSERT INTO foo (b) VALUES (randomblob(?))", len);
long rowid = db.last_insert_rowid();
byte[] blob = db.query_scalar <byte[]>("SELECT b FROM foo;");
Assert.AreEqual(blob.Length, len);
using (sqlite3_blob bh = db.blob_open("main", "foo", "b", rowid, 0))
{
int len2 = bh.bytes();
Assert.AreEqual(len, len2);
int passes = 10;
Assert.AreEqual(len % passes, 0);
int sublen = len / passes;
byte[] buf = new byte[sublen];
for (int q = 0; q < passes; q++)
{
bh.read(buf, q * sublen);
for (int i = 0; i < sublen; i++)
{
Assert.AreEqual(blob[q * sublen + i], buf[i]);
}
}
}
}
}
public static void close(this sqlite3_blob blob)
{
int rc = raw.sqlite3_blob_close(blob);
check_ok(rc);
}
public static int bytes(this sqlite3_blob blob)
{
return(raw.sqlite3_blob_bytes(blob));
}
public static void read(this sqlite3_blob blob, byte[] b, int bOffset, int len, int offset)
{
int rc = raw.sqlite3_blob_read(blob, b, bOffset, len, offset);
check_ok(rc);
}
public static void read(this sqlite3_blob blob, byte[] b, int offset)
{
int rc = raw.sqlite3_blob_read(blob, b, b.Length, offset);
check_ok(rc);
}
public static void reopen(this sqlite3_blob blob, long rowid)
{
int rc = raw.sqlite3_blob_reopen(blob, rowid);
check_ok(rc);
}
public static void read(this sqlite3_blob blob, Span <byte> b, int offset)
{
int rc = raw.sqlite3_blob_read(blob, b, offset);
check_ok(rc);
}
public static void write(this sqlite3_blob blob, ReadOnlySpan <byte> b, int offset)
{
int rc = raw.sqlite3_blob_write(blob, b, offset);
check_ok(rc);
}
public SQLiteBlobReadStream(sqlite3 db, sqlite3_blob blob)
{
_db = db;
Length = raw.sqlite3_blob_bytes(blob);
_blob = blob;
}
