ECode CStmt::BindZeroblob(
/* [in] */ Int32 pos,
/* [in] */ Int32 length)
{
#if HAVE_SQLITE3 && HAVE_SQLITE3_BIND_ZEROBLOB
hvm *v = (hvm *)mHandle;
if (v && v->vm && v->h) {
Int32 npar = sqlite3_bind_parameter_count((sqlite3_stmt *) v->vm);
Int32 ret = 0;
if (pos < 1 || pos > npar) {
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
ret = sqlite3_bind_zeroblob((sqlite3_stmt *) v->vm, pos, len);
if (ret != SQLITE_OK) {
mError_code = ret;
return E_SQL_EXCEPTION;
}
} else {
return E_NULL_POINTER_EXCEPTION;
}
#else
return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION;
#endif
return NOERROR;
}
/*
** Bind a blob value to an SQL statement variable.
*/
int sqlite3_bind_blob(
sqlite3_stmt *pStmt,
int i,
const void *zData,
int nData,
void (*xDel)(void*)
){
return bindText(pStmt, i, zData, nData, xDel, 0);
}
int sqlite3_bind_blob64(
sqlite3_stmt *pStmt,
int i,
const void *zData,
sqlite3_uint64 nData,
void (*xDel)(void*)
){
assert( xDel!=SQLITE_DYNAMIC );
if( nData>0x7fffffff ){
return invokeValueDestructor(zData, xDel, 0);
}else{
return bindText(pStmt, i, zData, (int)nData, xDel, 0);
}
}
int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
int rc;
Vdbe *p = (Vdbe *)pStmt;
rc = vdbeUnbind(p, i);
if( rc==SQLITE_OK ){
sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
sqlite3_mutex_leave(p->db->mutex);
}
return rc;
}
int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
return sqlite3_bind_int64(p, i, (i64)iValue);
}
int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
int rc;
Vdbe *p = (Vdbe *)pStmt;
rc = vdbeUnbind(p, i);
if( rc==SQLITE_OK ){
sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
sqlite3_mutex_leave(p->db->mutex);
}
return rc;
}
int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
int rc;
Vdbe *p = (Vdbe*)pStmt;
rc = vdbeUnbind(p, i);
if( rc==SQLITE_OK ){
sqlite3_mutex_leave(p->db->mutex);
}
return rc;
}
int sqlite3_bind_text(
sqlite3_stmt *pStmt,
int i,
const char *zData,
int nData,
void (*xDel)(void*)
){
return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
}
int sqlite3_bind_text64(
sqlite3_stmt *pStmt,
int i,
const char *zData,
sqlite3_uint64 nData,
void (*xDel)(void*),
unsigned char enc
){
assert( xDel!=SQLITE_DYNAMIC );
if( nData>0x7fffffff ){
return invokeValueDestructor(zData, xDel, 0);
}else{
if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
return bindText(pStmt, i, zData, (int)nData, xDel, enc);
}
}
#ifndef SQLITE_OMIT_UTF16
int sqlite3_bind_text16(
sqlite3_stmt *pStmt,
int i,
const void *zData,
int nData,
void (*xDel)(void*)
){
return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
}
#endif /* SQLITE_OMIT_UTF16 */
int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
int rc;
switch( sqlite3_value_type((sqlite3_value*)pValue) ){
case SQLITE_INTEGER: {
rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
break;
}
case SQLITE_FLOAT: {
rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
break;
}
case SQLITE_BLOB: {
if( pValue->flags & MEM_Zero ){
rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
}else{
rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
}
break;
}
case SQLITE_TEXT: {
rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
pValue->enc);
break;
}
default: {
rc = sqlite3_bind_null(pStmt, i);
break;
}
}
return rc;
}
int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
int rc;
Vdbe *p = (Vdbe *)pStmt;
sqlite3_mutex_enter(p->db->mutex);
if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
rc = SQLITE_TOOBIG;
}else{
assert( (n & 0x7FFFFFFF)==n );
rc = sqlite3_bind_zeroblob(pStmt, i, n);
}
rc = sqlite3ApiExit(p->db, rc);
sqlite3_mutex_leave(p->db->mutex);
return rc;
}
SWIGEXPORT jint JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1bind_1zeroblob(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jint jarg3) {
jint jresult = 0 ;
sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
int arg2 ;
int arg3 ;
int result;
(void)jenv;
(void)jcls;
arg1 = *(sqlite3_stmt **)&jarg1;
arg2 = (int)jarg2;
arg3 = (int)jarg3;
result = (int)sqlite3_bind_zeroblob(arg1,arg2,arg3);
jresult = (jint)result;
return jresult;
}
void JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1bind_1zeroblob(
JNIEnv *env, jclass cls, jlong handle, jint column, jint bytes)
{
if (handle == 0)
{
throwSqliteException(env, "handle is NULL");
return;
}
sqlite3_stmt* stmt = (sqlite3_stmt*) handle;
int rc = sqlite3_bind_zeroblob(stmt, column, bytes);
if (rc != SQLITE_OK)
{
sqlite3* conn = sqlite3_db_handle(stmt);
throwSqliteException2(env, sqlite3_errcode(conn), sqlite3_errmsg(conn));
}
}
int SQLiteSTMT::BindZeroBlob(int iCol, int len) {
return sqlite3_bind_zeroblob(handle, iCol, len);
}
static int
_bind_arg(lua_State *T, int t_idx, sqlite3_stmt *stmt, int s_idx)
{
int ret = 0;
int kind = lua_type(T, t_idx);
kind_is_known:
switch (kind) {
case LUA_TNIL:
/* Should nil mean NULL..
ret = sqlite3_bind_null(stmt, i-1);
break;
..or don't bind.. */
return SQLITE_OK;
case LUA_TNUMBER:
ret = sqlite3_bind_double(stmt, s_idx,
lua_tonumber(T, t_idx));
break;
case LUA_TSTRING:
{
size_t len;
const char *str = lua_tolstring(T, t_idx, &len);
ret = sqlite3_bind_text(stmt, s_idx,
str, len, SQLITE_STATIC);
}
break;
case BIND_INT:
ret = sqlite3_bind_int(stmt, s_idx,
lua_tointeger(T, t_idx));
break;
case BIND_INT64:
ret = sqlite3_bind_int(stmt, s_idx,
lua_tointeger(T, t_idx));
break;
case BIND_BLOB:
{
size_t len;
const char *str = lua_tolstring(T, t_idx, &len);
ret = sqlite3_bind_blob(stmt, s_idx,
str, len, SQLITE_STATIC);
}
break;
case BIND_BLOB64:
{
size_t len;
const char *str = lua_tolstring(T, t_idx, &len);
ret = sqlite3_bind_blob64(stmt, s_idx,
str, len, SQLITE_STATIC);
}
break;
case BIND_ZEROBLOB:
ret = sqlite3_bind_zeroblob(stmt, s_idx,
lua_tointeger(T, t_idx));
break;
case BIND_ZEROBLOB64:
ret = sqlite3_bind_zeroblob64(stmt, s_idx,
lua_tointeger(T, t_idx));
break;
case LUA_TTABLE:
{
lua_rawgeti(T, t_idx, 1);
kind = lua_tointeger(T, -1);
lua_pop(T, 1);
lua_rawgeti(T, t_idx, 2);
t_idx = -1;
goto kind_is_known;
}
default:
(void)sqlite3_clear_bindings(stmt);
return luaL_argerror(T, t_idx, "expected nil, number or string");
}
if (t_idx == -1) {
lua_pop(T, 1);
}
return ret;
}
void Database::Query::bindZeroBlob(int paramIndex, int numBytes)
{
if (_stmt == NULL || sqlite3_bind_zeroblob(_stmt, paramIndex, numBytes))
bindError(paramIndex);
}
DLL_FUNCTION(int32_t) BU_SQLite_Bind_ZeroBlob(sqlite3_stmt* pStmt, int32_t index, int32_t bytes) {
#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_ZeroBlob=_BU_SQLite_Bind_ZeroBlob@12")
return sqlite3_bind_zeroblob(pStmt, index, bytes);
}
/* --------------------------------------------------------------- */
void R_sqlbind( const int func )
{
int col, i;
double d;
char type;
if (!sqldb) Lerror(ERR_DATABASE,1);
if (!sqlstmt) Lerror(ERR_DATABASE,0);
if (ARGN==0) {
Licpy(ARGR, sqlite3_bind_parameter_count(sqlstmt));
return;
}
if (ARGN!=3) Lerror(ERR_INCORRECT_CALL,0);
if (Ldatatype(ARG1,'N'))
col = Lrdint(ARG1);
else {
LASCIIZ(*ARG1);
col = sqlite3_bind_parameter_index(sqlstmt, LSTR(*ARG1));
}
get_pad(2, type);
switch (type) {
case 'b': case 'B': /* blob */
Licpy(ARGR, sqlite3_bind_blob(sqlstmt, col,
LSTR(*ARG3), LLEN(*ARG3), SQLITE_TRANSIENT));
break;
case 'i': case 'I': /* integer */
get_i(3, i);
Licpy(ARGR, sqlite3_bind_int(sqlstmt, col, i));
break;
case 'd': case 'D': /* double */
case 'f': case 'F':
L2REAL(ARG3);
Licpy(ARGR, sqlite3_bind_double(sqlstmt, col, LREAL(*ARG3)));
break;
case 's': case 'S': /* double */
case 't': case 'T':
L2STR(ARG3);
Licpy(ARGR, sqlite3_bind_text(sqlstmt, col,
LSTR(*ARG3), LLEN(*ARG3), SQLITE_TRANSIENT));
break;
case 'n': case 'N': /* null */
Licpy(ARGR, sqlite3_bind_null(sqlstmt, col));
break;
case 'z': case 'Z': /* zero blob */
get_i(3, i);
Licpy(ARGR, sqlite3_bind_zeroblob(sqlstmt, col, i));
break;
default:
Lerror(ERR_INCORRECT_CALL,0);
}
} /* R_sqlbind */
void Statement::zeros(const char* arg_name, int size) {
if(size <= 0)
throw ValueError("The size must be greater that zero.");
if(sqlite3_bind_zeroblob(stmt, index(arg_name), size) != SQLITE_OK)
throw DBError(db, "The argument '%s' cannot be filled with zeros.", arg_name);
}
/**
@SYMTestCaseID PDS-SQLITE3-UT-4039
@SYMTestCaseDesc SQLITE3 - blob API tests.
List of called SQLITE3 functions:
- sqlite3_bind_zeroblob;
- sqlite3_blob_bytes;
- sqlite3_blob_close;
- sqlite3_blob_open;
- sqlite3_blob_read;
- sqlite3_blob_write;
- sqlite3_sql;
@SYMTestPriority High
@SYMTestActions SQLITE3 - blob API tests.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ10424
*/
static void TestSqliteBlobApi()
{
int err;
const char* tail = 0;
sqlite3_blob* blob = 0;
int bytes = 0;
const char KBlobData[] = "ABCDEFGH";
char sql[100];
const int KBlobLen = strlen(KBlobData);
const char* sql2 = 0;
const char KSqlFmt[] = "UPDATE BlobTbl SET B=:Prm WHERE ROWID=1";
TEST(TheDb != 0);
TEST(!TheStmt);
/* Create the table, insert one record with a blob */
err = sqlite3_exec(TheDb, "CREATE TABLE BlobTbl(I INTEGER PRIMARY KEY, B BLOB)", 0, 0, 0);
TEST2(err, SQLITE_OK);
sprintf(sql, "INSERT INTO BlobTbl VALUES(1, zeroblob(%d))", KBlobLen);
err = sqlite3_exec(TheDb, sql, 0, 0, 0);
TEST2(err, SQLITE_OK);
err = sqlite3_prepare_v2(TheDb, KSqlFmt, -1, &TheStmt, &tail);
TEST2(err, SQLITE_OK);
TEST(TheStmt != 0);
sql2 = sqlite3_sql(TheStmt);
TEST(sql2 != NULL);
err = strcmp(sql2, KSqlFmt);
TEST2(err, 0);
err = sqlite3_bind_zeroblob(TheStmt, 1, KBlobLen);
TEST2(err, SQLITE_OK);
err = sqlite3_step(TheStmt);
TEST2(err, SQLITE_DONE);
err = sqlite3_finalize(TheStmt);
TEST2(err, SQLITE_OK);
TheStmt = 0;
/* Open the blob and write to it */
err = sqlite3_blob_open(TheDb, "main", "BlobTbl", "B", 1, 1, &blob);
TEST2(err, SQLITE_OK);
TEST(blob != 0);
bytes = sqlite3_blob_bytes(blob);
TEST2(bytes, KBlobLen);
err = sqlite3_blob_write(blob, KBlobData, KBlobLen, 0);
TEST2(err, SQLITE_OK);
err = sqlite3_blob_close(blob);
TEST2(err, SQLITE_OK);
blob = 0;
/* Open the blob and read from it */
err = sqlite3_blob_open(TheDb, "main", "BlobTbl", "B", 1, 1, &blob);
TEST2(err, SQLITE_OK);
TEST(blob != 0);
bytes = sqlite3_blob_bytes(blob);
TEST2(bytes, KBlobLen);
err = sqlite3_blob_read(blob, sql, KBlobLen, 0);
TEST2(err, SQLITE_OK);
sql[bytes] = 0;
err = sqlite3_blob_close(blob);
TEST2(err, SQLITE_OK);
blob = 0;
err = strcmp(sql, KBlobData);
TEST2(err, 0);
err = sqlite3_exec(TheDb, "DROP TABLE BlobTbl", 0, 0, 0);
TEST2(err, SQLITE_OK);
}
/* The following function just stores the file (or silently returns if it already
exists).
The relationships of manifests to this file are the responsibility of the
caller. */
int rhizome_store_file(char *file,char *hash,int priority) {
int fd=open(file,O_RDONLY);
if (fd<0) return WHY("Could not open associated file");
struct stat stat;
if (fstat(fd,&stat)) {
close(fd);
return WHY("Could not stat() associated file");
}
unsigned char *addr =
mmap(NULL, stat.st_size, PROT_READ, MAP_FILE|MAP_SHARED, fd, 0);
if (addr==MAP_FAILED) {
close(fd);
return WHY("mmap() of associated file failed.");
}
/* Get hash of file if not supplied */
char hexhash[SHA512_DIGEST_STRING_LENGTH];
if (!hash)
{
/* Hash the file */
SHA512_CTX c;
SHA512_Init(&c);
SHA512_Update(&c,addr,stat.st_size);
SHA512_End(&c,hexhash);
hash=hexhash;
}
/* INSERT INTO FILES(id as text, data blob, length integer, highestpriority integer).
BUT, we have to do this incrementally so that we can handle blobs larger than available memory.
This is possible using:
int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
That binds an all zeroes blob to a field. We can then populate the data by
opening a handle to the blob using:
int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
*/
char sqlcmd[1024];
const char *cmdtail;
/* See if the file is already stored, and if so, don't bother storing it again */
int count=sqlite_exec_int64("SELECT COUNT(*) FROM FILES WHERE id='%s' AND datavalid<>0;",hash);
if (count==1) {
/* File is already stored, so just update the highestPriority field if required. */
long long storedPriority = sqlite_exec_int64("SELECT highestPriority FROM FILES WHERE id='%s' AND datavalid!=0",hash);
if (storedPriority<priority)
{
snprintf(sqlcmd,1024,"UPDATE FILES SET highestPriority=%d WHERE id='%s';",
priority,hash);
if (sqlite3_exec(rhizome_db,sqlcmd,NULL,NULL,NULL)!=SQLITE_OK) {
close(fd);
WHY(sqlite3_errmsg(rhizome_db));
return WHY("SQLite failed to update highestPriority field for stored file.");
}
}
close(fd);
return 0;
} else if (count>1) {
/* This should never happen! */
return WHY("Duplicate records for a file in the rhizome database. Database probably corrupt.");
}
/* Okay, so there are no records that match, but we should delete any half-baked record (with datavalid=0) so that the insert below doesn't fail.
Don't worry about the return result, since it might not delete any records. */
sqlite3_exec(rhizome_db,"DELETE FROM FILES WHERE datavalid=0;",NULL,NULL,NULL);
snprintf(sqlcmd,1024,"INSERT INTO FILES(id,data,length,highestpriority,datavalid) VALUES('%s',?,%lld,%d,0);",
hash,(long long)stat.st_size,priority);
sqlite3_stmt *statement;
if (sqlite3_prepare_v2(rhizome_db,sqlcmd,strlen(sqlcmd)+1,&statement,&cmdtail)
!= SQLITE_OK)
{
close(fd);
sqlite3_finalize(statement);
return WHY(sqlite3_errmsg(rhizome_db));
}
/* Bind appropriate sized zero-filled blob to data field */
int dud=0;
int r;
if ((r=sqlite3_bind_zeroblob(statement,1,stat.st_size))!=SQLITE_OK)
{
dud++;
WHY("sqlite3_bind_zeroblob() failed");
WHY(sqlite3_errmsg(rhizome_db));
}
/* Do actual insert, and abort if it fails */
if (!dud)
switch(sqlite3_step(statement)) {
case SQLITE_OK: case SQLITE_ROW: case SQLITE_DONE:
break;
default:
dud++;
WHY("sqlite3_step() failed");
WHY(sqlite3_errmsg(rhizome_db));
}
if (sqlite3_finalize(statement)) dud++;
if (dud) {
close(fd);
if (sqlite3_finalize(statement)!=SQLITE_OK)
{
WHY("sqlite3_finalize() failed");
WHY(sqlite3_errmsg(rhizome_db));
}
return WHY("SQLite3 failed to insert row for file");
}
/* Get rowid for inserted row, so that we can modify the blob */
int rowid=sqlite3_last_insert_rowid(rhizome_db);
if (rowid<1) {
close(fd);
WHY(sqlite3_errmsg(rhizome_db));
return WHY("SQLite3 failed return rowid of inserted row");
}
sqlite3_blob *blob;
if (sqlite3_blob_open(rhizome_db,"main","FILES","data",rowid,
1 /* read/write */,
&blob) != SQLITE_OK)
{
WHY(sqlite3_errmsg(rhizome_db));
close(fd);
sqlite3_blob_close(blob);
return WHY("SQLite3 failed to open file blob for writing");
}
{
long long i;
for(i=0;i<stat.st_size;i+=65536)
{
int n=65536;
if (i+n>stat.st_size) n=stat.st_size-i;
if (sqlite3_blob_write(blob,&addr[i],n,i) !=SQLITE_OK) dud++;
}
}
close(fd);
sqlite3_blob_close(blob);
/* Mark file as up-to-date */
sqlite_exec_int64("UPDATE FILES SET datavalid=1 WHERE id='%s';",
hash);
if (dud) {
WHY(sqlite3_errmsg(rhizome_db));
return WHY("SQLite3 failed write all blob data");
}
printf("stored file\n");
return 0;
}
