sqlite3_bind_blob when is safe to free memory? - c

Question

I have such working code:
const char sql[] = "INSERT INTO test (pk, geom) VALUES (?, ?)";
sqlite3_stmt *stmt;
sqlite3_prepare_v2 (handle, sql, strlen (sql), &stmt, NULL);
for (...) {
sqlite3_reset (stmt);
sqlite3_clear_bindings (stmt);
int blob_size = ..;
unsigned char *blob = malloc(blob_size);
sqlite3_bind_int64 (stmt, 1, pk);
sqlite3_bind_blob (stmt, 2, blob, blob_size, free);
sqlite3_step (stmt);
}
I wonder is it possible to not allocate and free on every step of cycle?
If I pass SQLITE_STATIC instead of free to sqlite3_bind_blob
and call free after end of cycle is this code still become valid?
const char sql[] = "INSERT INTO test (pk, geom) VALUES (?, ?)";
sqlite3_stmt *stmt;
sqlite3_prepare_v2 (handle, sql, strlen (sql), &stmt, NULL);
int capacity = 1024;
unsigned char *blob = malloc(capacity);
for (...) {
sqlite3_reset (stmt);
sqlite3_clear_bindings (stmt);
int blob_size = ..;
if (capacity < blob_size) {
blob = realloc(blob, blob_size);
capacity = blob_size;
}
sqlite3_bind_int64 (stmt, 1, pk);
sqlite3_bind_blob (stmt, 2, blob, blob_size, SQLITE_STATIC);
sqlite3_step (stmt);
}
free(blob);

Answer 1

Using SQLITE_STATIC requires that the value stays valid as long as the statement might access it.
Your code should be valid; but to be sure, move the call to sqlite3_clear_bindings() (and the reset) to the end of the loop.

Answer 2

Question: If I pass SQLITE_STATIC instead of free to sqlite3_bind_blob and call free after end of cycle is this code still become valid?
Answer: No.
SQLite documentation on sqlite3_bind_blob():
If the fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its own private copy of the data immediately, before the sqlite3_bind_*() routine returns.
This implies that when the fifth argument does not have this value (in particular, when the fifth argument has the value SQLITE_STATIC), SQLite may still require the data after the routine returns. In that case, no guarantees are made about how long SQLite may require the data (except, presumably, SQLite will not require anything after sqlite3_close() is called).

Answer 3

From the SQLite docs:
The fifth argument to the BLOB and string binding interfaces is a destructor used to dispose of the BLOB or string after SQLite has finished with it. The destructor is called to dispose of the BLOB or string even if the call to bind API fails. If the fifth argument is the special value SQLITE_STATIC, then SQLite assumes that the information is in static, unmanaged space and does not need to be freed. If the fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its own private copy of the data immediately, before the sqlite3_bind_*() routine returns.
If you're reallocating the memory, you should use SQLITE_TRANSIENT. That way SQLite won't make any assumptions about being able to rely on that memory, it will make its own copy.
Note that the docs don't say anything about exactly when the specified destructor (if any) is called -- only that it is called when SQLite is finished with the BLOB. If you don't want to use SQLITE_TRANSIENT, then you should NOT use SQLITE_STATIC, because SQLite may or may not assume that the memory is available when it actually isn't anymore.