/*!
ＩＤを指定してデータゲット
@param[in] id 検索するＩＤ
@param[out] ptFilePath ファイルパスバッファ・MAX_PATHであること
@param[out] ptBaseName ルート直下のディレクトリ名バッファ・MAX_PATHであること
@param[in] ptDispName タブの表示名・MAX_PATHであること
@return UINT 引っ張ったヤツのID番号・ヒットしなかったら０
*/
UINT SqlMultiTabSelect( INT id, LPTSTR ptFilePath, LPTSTR ptBaseName, LPTSTR ptDispName )
{
CHAR acQuery[MAX_STRING];
INT rslt;
UINT index = 0;
sqlite3_stmt* statement;
if( !(gpDataBase) ){ return 0; }
StringCchPrintfA( acQuery, MAX_STRING, ("SELECT * FROM MultiTab WHERE id == %d"), id );
rslt = sqlite3_prepare( gpDataBase, acQuery, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( gpDataBase ); return 0; }
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt )
{
index = sqlite3_column_int( statement , 0 ); // id
String_Cch_Copy( ptFilePath, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 1 ) ); // filepath
String_Cch_Copy( ptBaseName, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 2 ) ); // basename
String_Cch_Copy( ptDispName, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 3 ) ); // dispname
}
sqlite3_finalize( statement );
return index;
}
wxString CQueueStorage::Impl::GetColumnText(sqlite3_stmt* statement, int index, bool shrink)
{
wxString ret;
#ifdef __WXMSW__
(void)shrink;
const wxChar* text = static_cast<const wxChar*>(sqlite3_column_text16(statement, index));
if (text)
ret = text;
#else
const char* text = static_cast<const char*>(sqlite3_column_text16(statement, index));
int len = sqlite3_column_bytes16(statement, index);
if (text)
{
wxStringBuffer buffer(ret, len);
wxChar* out = buffer;
int outlen = utf16_.ToWChar( out, len, text, len );
buffer[outlen] = 0;
}
if (shrink)
ret.Shrink();
#endif
return ret;
}
int RecorderDAO::RetrieveRecorders(SITE_T * site, RECORDER_T *** recorders, int & count, sqlite3 * connection)
{
int value = DAO_FAIL;
sqlite3_stmt *stmt;
sqlite3 *conn;
if (connection == 0)
conn = _db;
else
conn = connection;
if (!site)
return value;
count = RetrieveRecorderCount(site, conn);
*recorders = static_cast<RECORDER_T**>(malloc(sizeof(RECORDER_T*)*count));
std::string sql = "SELECT uuid, name, address, username, pwd FROM tb_recorder WHERE uuid in (SELECT recorder_uuid FROM tb_site_recorder WHERE site_uuid=?) ORDER BY name ASC;";
if (sqlite3_prepare(conn, sql.c_str(), -1, &stmt, 0) == SQLITE_OK)
{
sqlite3_bind_text16(stmt, 1, site->uuid, -1, 0);
int result = SQLITE_ERROR;
int index = 0;
while (true)
{
result = sqlite3_step(stmt);
if (result == SQLITE_ROW)
{
(*recorders)[index] = static_cast<RECORDER_T*>(malloc(sizeof(RECORDER_T)));
wchar_t * uuid = (wchar_t*)sqlite3_column_text16(stmt, 0);
wchar_t * name = (wchar_t*)sqlite3_column_text16(stmt, 1);
wchar_t * address = (wchar_t*)sqlite3_column_text16(stmt, 2);
wchar_t * username = (wchar_t*)sqlite3_column_text16(stmt, 3);
wchar_t * pwd = (wchar_t*)sqlite3_column_text16(stmt, 4);
wcscpy((*recorders)[index]->uuid, uuid);
wcscpy((*recorders)[index]->name, name);
wcscpy((*recorders)[index]->address, address);
wcscpy((*recorders)[index]->username, username);
wcscpy((*recorders)[index]->pwd, pwd);
index++;
value = DAO_SUCCESS;
}
else
{
if (result == SQLITE_DONE)
value = DAO_SUCCESS;
break;
}
}
}
sqlite3_reset(stmt);
sqlite3_finalize(stmt);
return value;
}
uint64
O2DatDB::
select_datcount(wstrnummap &out)
{
#if TRACE_SQL_EXEC_TIME
stopwatch sw("select datcount group by domain bbsname");
#endif
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
wstring domain_bbsname;
uint64 total = 0;
uint64 num;
int err = sqlite3_open16(dbfilename.c_str(), &db);
if (err != SQLITE_OK)
goto error;
sqlite3_busy_timeout(db, 5000);
wchar_t *sql =
L"select domain, bbsname, count(*) from dat group by domain, bbsname;";
err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL);
if (err != SQLITE_OK)
goto error;
while (sqlite3_step(stmt) == SQLITE_ROW) {
domain_bbsname = (wchar_t*)sqlite3_column_text16(stmt, 0);
domain_bbsname += L":";
domain_bbsname += (wchar_t*)sqlite3_column_text16(stmt, 1);
num = sqlite3_column_int64(stmt, 2);
out.insert(wstrnummap::value_type(domain_bbsname, num));
total += num;
}
sqlite3_finalize(stmt);
stmt = NULL;
err = sqlite3_close(db);
if (err != SQLITE_OK)
goto error;
return (total);
error:
log(db);
if (stmt) sqlite3_finalize(stmt);
if (db) sqlite3_close(db);
return false;
}
void
O2DatDB::
get_columns(sqlite3_stmt* stmt, O2DatRec &rec)
{
rec.hash.assign((byte*)sqlite3_column_blob(stmt, 0), HASHSIZE);
rec.domain = (wchar_t*)sqlite3_column_text16(stmt, 1);
rec.bbsname = (wchar_t*)sqlite3_column_text16(stmt, 2);
rec.datname = (wchar_t*)sqlite3_column_text16(stmt, 3);
rec.size = sqlite3_column_int64 (stmt, 4);
rec.disksize = sqlite3_column_int64 (stmt, 5);
rec.url = (wchar_t*)sqlite3_column_text16(stmt, 6);
rec.title = (wchar_t*)sqlite3_column_text16(stmt, 7);
rec.res = sqlite3_column_int64 (stmt, 8);
rec.lastupdate = sqlite3_column_int64 (stmt, 9);
rec.lastpublish = sqlite3_column_int64 (stmt, 10);
}
/*!
親ＩＤ指定してリストアップ
@param[in] dPrntID 親ＩＤ
@param[in] tgtID この番号を超えて最初にヒットしたやつを返す
@param[out] pType ディレクトリ(FILE_ATTRIBUTE_DIRECTORY)かファイルか(FILE_ATTRIBUTE_NORMAL)
@param[out] ptName ノードの名称
@return UINT 引っ張ったやつのＩＤ・無かったら０
*/
UINT SqlChildNodePickUpID( UINT dPrntID, UINT tgtID, PUINT pType, LPTSTR ptName )
{
CHAR acQuery[MAX_PATH];
INT rslt;
UINT id = 0, dummy;
sqlite3_stmt* statement;
StringCchPrintfA( acQuery, MAX_PATH, ("SELECT * FROM TreeNode WHERE parentid == %u AND id > %u ORDER BY id ASC"), dPrntID, tgtID );
rslt = sqlite3_prepare( gpDataBase, acQuery, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( gpDataBase ); return 0; }
sqlite3_reset( statement );
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt )
{
id = sqlite3_column_int( statement, 0 ); // id
*pType = sqlite3_column_int( statement, 1 ); // type
dummy = sqlite3_column_int( statement, 2 ); // parentid
String_Cch_Copy( ptName, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 3 ) ); // nodename
}
sqlite3_finalize( statement );
return id;
}
/**
Reads a record from security policies table.
@param aStmtHandle Statement handle. It cannot be NULL.
@param aSecurityPolicy Security policies container.
@param aObjType Output parameter, will be initialized with the database object type: KDefaultObjType,
KDbObjType, RSqlSecurityPolicy::ETable.
@param aObjName Output parameter, database object name (for example, table name), which is protected by the
current security policy.
@param aPolicyType Output parameter, will be initialized with the database policy type: RSqlSecurityPolicy::EReadPolicy,
RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy.
@return The created security policy object.
@leave KErrGeneral, invalid security policy data;
KErrNoMemory, Out of memory.
*/
TSecurityPolicy TSqlDbSysSettings::ReadCurrSecurityPolicyL(sqlite3_stmt* aStmtHandle, TInt& aObjType,
TPtrC& aObjName, TInt& aPolicyType)
{
__ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC(ESqlPanicBadArgument));
aObjType = sqlite3_column_int(aStmtHandle, KObjTypeColIdx);
//The "ObjectName" column type might be different than SQLITE_TEXT - malformed database.
if(sqlite3_column_type(aStmtHandle, KObjNameColIdx) != SQLITE_TEXT)
{
__SQLLEAVE(KErrGeneral);
}
const void* text = sqlite3_column_text16(aStmtHandle, KObjNameColIdx);
//Null column value - this might be an indication of an "out of memory" problem, if the column text
//is in UTF8 format. (sqlite3_column_text16() may allocate memory for UTF8->UTF16 conversion)
__SQLLEAVE_IF_NULL(const_cast<void*>(text));
TInt len = (TUint)sqlite3_column_bytes16(aStmtHandle, KObjNameColIdx) / sizeof(TUint16);
aObjName.Set(reinterpret_cast <const TUint16*> (text), len);
aPolicyType = sqlite3_column_int(aStmtHandle, KObjPolicyTypeColIdx);
len = sqlite3_column_bytes(aStmtHandle, KObjPolicyDataColIdx);
if(len != sizeof(TSecurityPolicy))
{
//Check if the error is "out of memory" (which may happen when retrieving text column data
//and the column encoding is different, in which case the column text has to be converted
//and a new block of memory has to be allocated for the conversion).
TInt err2 = ::StmtReset(aStmtHandle);
__SQLLEAVE(err2 == KErrNoMemory ? KErrNoMemory : KErrGeneral);
}
const void* data = sqlite3_column_blob(aStmtHandle, KObjPolicyDataColIdx);
TSecurityPolicy policy;
policy.Set(TPtrC8(reinterpret_cast <const TUint8*> (data), len));
return policy;
}
/**
result_next : 'result -> object?
<doc>Returns the next row in the result or [null] if no more result.</doc>
**/
HL_PRIM varray *HL_NAME(result_next)( sqlite_result *r ) {
if( r->done )
return NULL;
switch( sqlite3_step(r->r) ) {
case SQLITE_ROW:
r->first = 0;
varray *a = hl_alloc_array(&hlt_dyn, r->ncols);
int i;
for(i=0;i<r->ncols;i++)
{
vdynamic *v;
switch( sqlite3_column_type(r->r,i) ) {
case SQLITE_NULL:
v = NULL;
break;
case SQLITE_INTEGER:
{
int vint = sqlite3_column_int(r->r, i);
if (r->bools[i])
v = hl_make_dyn(&vint, &hlt_bool);
else
v = hl_make_dyn(&vint, &hlt_i32);
break;
}
case SQLITE_FLOAT:
{
double d = sqlite3_column_double(r->r, i);
v = hl_make_dyn(&d, &hlt_f64);
break;
}
case SQLITE_TEXT:
{
uchar *text16 = (uchar *)sqlite3_column_text16(r->r, i);
v = hl_make_dyn(&text16, &hlt_bytes);
break;
}
case SQLITE_BLOB:
{
vbyte *blob = (vbyte *)sqlite3_column_blob(r->r, i);
v = hl_make_dyn(&blob, &hlt_bytes);
break;
}
default:
hl_error_msg(USTR("SQLite error: Unknown type #%d"), sqlite3_column_type(r->r,i));
}
hl_aptr(a, vdynamic*)[i] = v;
}
return a;
case SQLITE_DONE:
HL_NAME(finalize_request)(r, true);
return NULL;
case SQLITE_BUSY:
hl_error("SQLite error: Database is busy");
case SQLITE_ERROR:
HL_NAME(error)(r->db->db, false);
default:
return NULL;
}
return NULL;
}
/*!
登録されているルート名をリストアップしてコールバックする
@param[in] pfFolderNameSet 内容をコールバックする函数ポインター
@return HRESULT 終了状態コード
*/
HRESULT SqlFavFolderEnum( BUFFERBACK pfFolderNameSet )
{
CONST CHAR acQuery[] = { ("SELECT DISTINCT folder FROM ArtList") };
INT rslt, count, i;
sqlite3_stmt *statement;
if( !(pfFolderNameSet) ){ return E_INVALIDARG; }
if( !(gpDataBase) ){ return E_OUTOFMEMORY; }
count = SqlFavCount( NULL, NULL );
rslt = sqlite3_prepare( gpDataBase, acQuery, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( gpDataBase ); return E_FAIL; }
rslt = sqlite3_reset( statement );
for( i = 0; count > i; i++ )
{
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt )
{
pfFolderNameSet( i, 0, 0, sqlite3_column_text16( statement, 0 ) );
}
else{ break; }
}
sqlite3_finalize(statement);
return S_OK;
}
/* column bytes 16 */
const char16_t *
sqlite_statement::column_const_char16_t_ptr (
int _index
){
return reinterpret_cast<const char16_t*>
(sqlite3_column_text16(this->stmt, _index));
}
/*!
ＩＤ指定してリストアップ
@param[in] seekID １以上の場合、このIDのを探す。こっち優先
@param[in] tgtID この番号を超えて最初にヒットしたやつを返す・seekIDが０の場合
@param[out] ptName ノードのパスいれるバッファ・MAX_PATHであること
@return UINT 引っ張ったやつのＩＤ・無かったら０
*/
UINT SqlTreeNodeExtraSelect( UINT seekID, UINT tgtID, LPTSTR ptName )
{
//LPCTSTR ptBuffer;
CHAR acQuery[MAX_STRING];
INT rslt;
UINT id = 0;
sqlite3_stmt* statement;
if( !(gpDataBase) ){ TRACE( TEXT("NoDatabase") ); return 0; }
if( 1 <= seekID ){ StringCchPrintfA( acQuery, MAX_STRING, ("SELECT id, nodename FROM TreeNode WHERE id == %u"), seekID ); }
else{ StringCchPrintfA( acQuery, MAX_STRING, ("SELECT id, nodename FROM TreeNode WHERE id > %u AND parentid == -1 ORDER BY id ASC"), tgtID ); }
rslt = sqlite3_prepare( gpDataBase, acQuery, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( gpDataBase ); return 0; }
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt )
{
id = sqlite3_column_int( statement, 0 ); // id
String_Cch_Copy( ptName, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 1 ) ); // nodename
//ptBuffer = (LPCTSTR)sqlite3_column_text16( statement, 1 ); // nodename
//if( ptBuffer ){ StringCchCopy( ptName, MAX_PATH, ptBuffer ); }
}
sqlite3_finalize( statement );
return id;
}
static JSVAL sqlite_column_text16(JSARGS args) {
HandleScope scope;
Local<External>wrap = Local<External>::Cast(args[0]);
sqlite3_stmt *stmt = (sqlite3_stmt *)wrap->Value();
int iCol = args[1]->IntegerValue();
return scope.Close(String::New((char *)sqlite3_column_text16(stmt, iCol)));
}
/*!
ＩＤ指定してリストアップ
@param[in] tgtID この番号を超えて最初にヒットしたやつを返す
@param[out] pType ディレクトリ(FILE_ATTRIBUTE_DIRECTORY)かファイルか(FILE_ATTRIBUTE_NORMAL)
@param[out] pPrntID 親ツリーノードのSQL的ＩＤ番号
@param[out] ptName ノードの名称
@param[in] bStyle 0x01通常 0x00ツリーキャッシュ ／ 0x10ＩＤ一致 0x00ＩＤ超えた
@return UINT 引っ張ったやつのＩＤ・無かったら０
*/
UINT SqlTreeNodePickUpID( UINT tgtID, PUINT pType, PUINT pPrntID, LPTSTR ptName, UINT bStyle )
{
CHAR acQuery[MAX_STRING];
INT rslt;
UINT id = 0;
sqlite3_stmt* statement;
sqlite3 *pDB;
if( bStyle & 0x01 ){ pDB = gpDataBase; }
else{ pDB = gpTreeCache; }
if( !(pDB) ){ return 0; }
if( bStyle & 0x10 ){ StringCchPrintfA( acQuery, MAX_STRING, ("SELECT * FROM TreeNode WHERE id == %u"), tgtID ); }
else{ StringCchPrintfA( acQuery, MAX_STRING, ("SELECT * FROM TreeNode WHERE id > %u ORDER BY id ASC"), tgtID ); }
rslt = sqlite3_prepare( pDB, acQuery, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( pDB ); return 0; }
sqlite3_reset( statement );
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt )
{
id = sqlite3_column_int( statement, 0 ); // id
*pType = sqlite3_column_int( statement, 1 ); // type
*pPrntID = sqlite3_column_int( statement, 2 ); // parentid
String_Cch_Copy( ptName, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 3 ) ); // nodename
}
sqlite3_finalize( statement );
return id;
}
static void get_column_Text(row r, int index, Text& val)
{
#if defined(_UNICODE) || defined(UNICODE)
val = (const TCHAR*)sqlite3_column_text16(r, index);
#else
val = (const TCHAR*)sqlite3_column_text(r, index);
#endif
}
DBString asString() const
{
#ifdef DB_UTF16
return (const wchar_t*)sqlite3_column_text16(_stmt, _fieldIndex);
#else
return (const char*)sqlite3_column_text(_stmt, _fieldIndex);
#endif
}
// 获取某列的值(字符串)
LPCTSTR SQLiteDataReader::GetStringValue(int nCol)
{
#ifdef UNICODE
return (LPCTSTR)sqlite3_column_text16(m_pStmt, nCol);
#else
return (LPCTSTR)sqlite3_column_text(m_pStmt, nCol);
#endif
}
bool Reader::GetString(int index, CString & val)
{
if(! IsValidIndex(index))
{
return false;
}
val = (LPCTSTR) sqlite3_column_text16(m_cmd->m_st, index);
return true;
}
/**
result_get : 'result -> n:int -> string
<doc>Return the [n]th field of the current result row.</doc>
**/
HL_PRIM vbyte *HL_NAME(result_get)( sqlite_result *r, int n ) {
if (n < 0 || n >= r->ncols)
return NULL;
if( r->first )
HL_NAME(result_next)(r);
if( r->done )
return NULL;
return (vbyte*)sqlite3_column_text16(r->r, n);
}
std::unique_ptr<SQLiteResult> SQLiteQuery::Execute()
{
std::unique_ptr<SQLiteResult> out_result(new SQLiteResult());
char* err_info = query;
while (1)
{
int result = sqlite3_step(stmt);
if (result == SQLITE_DONE) break;
if (result == SQLITE_ROW) { // data!
/*if (!out_result) { // no data was expected
error = SQL_ERRCODE_NDE;
break;
}*/
std::unique_ptr<SQLiteRow> row(new SQLiteRow());
int columns = sqlite3_column_count(stmt);
for (int x = 0; x < columns; x++) {
int type = sqlite3_column_type(stmt, x);
const char* name = sqlite3_column_name(stmt, x);
switch (type)
{
case SQLITE_INTEGER:
row->AddColumn(Object::unique_ptr(
new ObjNumber(sqlite3_column_int(stmt, x))), name);
break;
case SQLITE_FLOAT:
row->AddColumn(Object::unique_ptr(
new ObjNumber(sqlite3_column_double(stmt, x))), name);
break;
case SQLITE_TEXT:
row->AddColumn(Object::unique_ptr(
new ObjWString((const wchar_t*)sqlite3_column_text16(stmt, x))),
name);
break;
case SQLITE_BLOB:
row->AddColumn(Object::unique_ptr(
new ObjBlob((BYTE*)sqlite3_column_blob(stmt, x),
sqlite3_column_bytes(stmt, x))),
name);
break;
}
}
out_result->AddRow(std::move(row));
}
else { // error
throw SQLiteError(parent.LastError());
}
}
sqlite3_finalize(stmt);
stmt = NULL;
return out_result;
}
String SQLiteStatement::getColumnText(int col)
{
ASSERT(col >= 0);
if (!m_statement)
if (prepareAndStep() != SQLITE_ROW)
return String();
if (columnCount() <= col)
return String();
return String(reinterpret_cast<const UChar*>(sqlite3_column_text16(m_statement, col)), sqlite3_column_bytes16(m_statement, col) / sizeof(UChar));
}
const TCHAR* CppSQLite3Query::fieldValue(const TCHAR* szField)
{
int nField = fieldIndex(szField);
#ifdef _UNICODE
return (const TCHAR*)sqlite3_column_text16(mpVM, nField);
#else
return (const TCHAR*)sqlite3_column_text(mpVM, nField);
#endif
}
/*
* Class: com_sabo_sqlite_SQLiteDatabase_SQLiteQuery
* Method: nativeQuery
* Signature: (J)[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_com_sabo_sqlite_SQLiteDatabase_00024SQLiteQuery_nativeQuery
(JNIEnv *env, jobject clazz, jlong statementPtr) {
sqlite3_stmt *pStmt;
jobjectArray objArray;
int nCol;
int i;
int rc;
int nLen;
jchar *zVal;
jclass clazzString;
jstring val;
assert(statementPtr != 0);
pStmt = (sqlite3_stmt *)statementPtr;
nCol = sqlite3_column_count(pStmt);
assert(nCol > 0);
clazzString = env->FindClass("java/lang/String");
assert(clazzString != NULL);
/**
Ignore to check clazzString.
*/
if (nCol <= 0) throw_sqlite3_exception(env, "[SQLite]: nCol is less than 1.");
objArray = env->NewObjectArray(nCol, clazzString, NULL);
if (objArray == NULL) throw_sqlite3_exception(env, "[SQLite]: Allocate objArray failed (No enough memory)");
rc = sqlite3_step(pStmt);
if (rc == SQLITE_ROW) {
for (i = 0; i < nCol; ++i) {
zVal = (jchar *)sqlite3_column_text16(pStmt, i);
nLen = 0;
if (zVal) {
nLen = sqlite3_column_bytes16(pStmt, i);
assert(nLen > 0);
}
if (nLen > 0) {
val = env->NewString(zVal, nLen/sizeof(jchar));
assert(val != NULL);
if (val == NULL) throw_sqlite3_exception(env, "[SQLite]: NewString failed...");
}
else {
val = NULL;
}
env->SetObjectArrayElement(objArray, i, val);
}
}
else {
if (rc == SQLITE_OK || rc == SQLITE_DONE) {
return NULL;
}
throw_sqlite3_exception(env, "[SQLITE]: Fail to run sqltie3_step.");
}
return objArray;
}
void Sqlite3Connection::GetColumn(int i, Ref f) const {
ASSERT(NULL != current_stmt);
if(i == -1) {
f = Value(sqlite3_last_insert_rowid(db));
return;
}
ASSERT(got_row_data);
String coltype;
const char *s = sqlite3_column_decltype(current_stmt,i);
if(s) coltype = ToLower(s);
switch (sqlite3_column_type(current_stmt,i)) {
case SQLITE_INTEGER:
f = sqlite3_column_int64(current_stmt,i);
break;
case SQLITE_FLOAT:
f = sqlite3_column_double(current_stmt,i);
break;
case SQLITE_TEXT:
if(coltype == "date" || f.GetType() == DATE_V){
const char *s = (const char *)sqlite3_column_text(current_stmt, i);
if(strlen(s) >= 10)
f = Value(Date(atoi(s), atoi(s + 5), atoi(s + 8)));
else
f = Null;
}
else
if(coltype == "datetime" || f.GetType() == TIME_V) {
const char *s = (const char *)sqlite3_column_text(current_stmt, i);
if(strlen(s) >= 19)
f = Value(Time(atoi(s), atoi(s + 5), atoi(s + 8), atoi(s + 11), atoi(s + 14), atoi(s + 17)));
else
if(strlen(s) >= 10)
f = Value(ToTime(Date(atoi(s), atoi(s + 5), atoi(s + 8))));
else
f = Null;
}
else
f = Value(WString((const wchar*)sqlite3_column_text16(current_stmt,i)));
break;
case SQLITE_NULL:
f = Null;
break;
case SQLITE_BLOB:
f = Value(String( (const byte*)sqlite3_column_blob(current_stmt,i),
sqlite3_column_bytes(current_stmt,i) ));
break;
default:
NEVER();
break;
}
return;
}
const unsigned short* CppSQLite3Query::fieldValue16(const CString& szField)
{
checkVM();
int nField = fieldIndex(szField);
if (nField < 0 || nField > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR, "Invalid field index requested");
}
return (const unsigned short*)sqlite3_column_text16(mpVM, nField);
}
/*!
使ったAAを、リスト確認して追加したり更新したり
@param[in] ptBaseName 基点ディレクトリ名
@param[in] dHash ＡＡ認識用のハッシュ値
@param[in] pcConts ＡＡ本体
@param[in] rdLength バイト数
@return HRESULT 終了状態コード
*/
HRESULT SqlFavUpload( LPTSTR ptBaseName, DWORD dHash, LPSTR pcConts, UINT rdLength )
{
CONST CHAR acArtSelect[] = { ("SELECT id, folder FROM ArtList WHERE hash == ?") };
INT rslt;
UINT index, cntID, d;
//LPCTSTR ptFolder;
TCHAR atFolder[MAX_PATH];
BOOLEAN bIsExist;
sqlite3_stmt *statement;
rslt = sqlite3_prepare( gpDataBase, acArtSelect, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( gpDataBase ); return E_OUTOFMEMORY; }
bIsExist = FALSE;
cntID = SqlFavCount( NULL, NULL );
//先に登録した後、そのＡＡのベースネームが変わった場合、新しい名前で出てこない問題
//ハッシュで見てるので、ＡＡ自体は一つしか登録されない
//＞ベース名まで確認すればいい。ヒットしなくなるまで回して、ベース名がなかったら新規追加
sqlite3_reset( statement );
sqlite3_bind_int( statement, 1, dHash ); // hash
for( d = 0; cntID > d; d++ ) // 全数回せばおｋ
{
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt ) // 存在した
{
ZeroMemory( atFolder, sizeof(atFolder) );
index = sqlite3_column_int( statement , 0 ); // id
String_Cch_Copy( atFolder, MAX_PATH, (LPCTSTR)sqlite3_column_text16( statement, 1 ) ); // folder
//ptFolder = (LPCTSTR)sqlite3_column_text16( statement, 1 );
//if( ptFolder ){ StringCchCopy( atFolder, MAX_PATH, ptFolder ); }
SqlFavUpdate( index ); // 内容更新
// ベース名チェキ・同じのがあればおｋ
if( !( StrCmp( ptBaseName, atFolder ) ) ){ bIsExist = TRUE; }
}
else{ break; } // それ以上ないなら終わる
}
sqlite3_finalize( statement );
if( !(bIsExist) ) // 未記録のなら項目追加
{
SqlFavInsert( ptBaseName, dHash, pcConts, rdLength );
}
return S_OK;
}
bool sqlite_db::step()
{
if(!_stmt)
return false;
sqlite3_stmt* stmt=(sqlite3_stmt*)_stmt;
int ret=sqlite3_step(stmt);
if(ret==SQLITE_DONE)
{
if(sqlite3_column_count(stmt))
_array_res.push_back(sqlite_res()); // check if the statement will produce resultset, add a blank even if no rows to keep consistent
return true;
}
if(ret!=SQLITE_ROW)
{
_err_msg=(const wchar_t*)sqlite3_errmsg16((sqlite3*)_handle);
return false;
}
if(ret==SQLITE_ROW)
_array_res.push_back(sqlite_res());
sqlite_res& res=*(_array_res.end()-1);
int row=0;
while(ret==SQLITE_ROW)
{
res._res.push_back(vector<sqlite_res::VALUE>());
int i;
int count=sqlite3_column_count(stmt);
for(i=0;i<count;++i)
{
res._res[row].push_back(sqlite_res::VALUE());
int type=sqlite3_column_type(stmt,i);
if(type==SQLITE_NULL)
continue;
if(type==SQLITE_BLOB)
{
if(!sqlite3_column_bytes(stmt,i))
continue;
vector<char>& blob=res._res[row][i].blob;
blob.resize(sqlite3_column_bytes(stmt,i));
memcpy(&blob[0],sqlite3_column_blob(stmt,i),sqlite3_column_bytes(stmt,i));
continue;
}
res._res[row][i].text=(const wchar_t*)sqlite3_column_text16(stmt,i);
}
++row;
ret=sqlite3_step(stmt);
}
return true;
}
const TCHAR* CppSQLite3Query::getStringField(int nField, const TCHAR* szNullValue/*=""*/)
{
if (fieldDataType(nField) == SQLITE_NULL)
{
return szNullValue;
}
else
{
#ifdef _UNICODE
return (const TCHAR*)sqlite3_column_text16(mpVM, nField);
#else
return (const TCHAR*)sqlite3_column_text(mpVM, nField);
#endif
}
}
/*!
プロフ名、ルートパスを確保
@param[out] ptProfName プロフ名入れる
@param[in] szName プロフ名の文字数
@param[out] ptRootPath AAのルートダディレクトリ名
@param[in] szRoot ルートダディの文字数
@return HRESULT 終了状態コード
*/
HRESULT SqlTreeProfSelect( LPTSTR ptProfName, UINT szName, LPTSTR ptRootPath, UINT szRoot )
{
CONST CHAR cacSelectQuery[] = { ("SELECT * FROM Profiles WHERE id == 1") };
//LPTSTR ptBuf;
TCHAR atName[MAX_STRING], atRoot[MAX_PATH];
INT index;
INT rslt;
sqlite3_stmt *statement;
ZeroMemory( atName, sizeof(atName) );
ZeroMemory( atRoot, sizeof(atRoot) );
// クェリセット
rslt = sqlite3_prepare( gpDataBase, cacSelectQuery, -1, &statement, NULL );
if( SQLITE_OK != rslt ){ SQL_DEBUG( gpDataBase ); return E_OUTOFMEMORY; }
rslt = sqlite3_reset( statement );
// 内容を読み出し
rslt = sqlite3_step( statement );
if( SQLITE_ROW == rslt )
{
index = sqlite3_column_int( statement , 0 ); // id
String_Cch_Copy( atName , MAX_STRING, (LPTSTR)sqlite3_column_text16( statement, 1 ) ); // profname
String_Cch_Copy( atRoot , MAX_STRING, (LPTSTR)sqlite3_column_text16( statement, 2 ) ); // rootpath
//ptBuf = (LPTSTR)sqlite3_column_text16( statement, 2 ); // rootpath
//if( ptBuf ){ StringCchCopy( atRoot , MAX_PATH, ptBuf ); }
}
sqlite3_finalize( statement );
if( ptProfName ) StringCchCopy( ptProfName, szName, atName );
if( ptRootPath ) StringCchCopy( ptRootPath, szRoot, atRoot );
return S_OK;
}
static jstring nativeExecuteForString(JNIEnv* env, jclass clazz,
jlong connectionPtr, jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
int err = executeOneRowQuery(env, connection, statement);
if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
const jchar* text = static_cast<const jchar*>(sqlite3_column_text16(statement, 0));
if (text) {
size_t length = sqlite3_column_bytes16(statement, 0) / sizeof(jchar);
return env->NewString(text, length);
}
}
return NULL;
}
/**
@SYMTestCaseID SYSLIB-SQLITE3-UT-4025
@SYMTestCaseDesc SQLite library single-select performance test.
The test selects one record and stores
the execution time for later use (comparison and printing).
The ID of the selected record is exactly the same as the ID of the selected
record, used by SYSLIB-SQLITE3-UT-4017 test case.
The results of this test case will be compared against the results of
the SYSLIB-SQLITE3-UT-4017 test case - "SQL server single-select performance test".
@SYMTestPriority High
@SYMTestActions SQLite library single-select performance test.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ8782
*/
void SqliteSingleSelectTest(TPerfTestMode aPerfTestMode, const char aSingleSelectSql[], TInt aSelectRecId)
{
int err;
const char* tail = 0;
sqlite3_stmt* stmt = 0;
int recCnt = 0;
unsigned int fc;
char tmp[10];
TEST(aPerfTestMode > EPerfTestSqlMode && aPerfTestMode < EPerfTestModeCnt);
TEST(!TheDb2);
err = sqlite3_open(TestDbName(), &TheDb2);
TEST2(err, SQLITE_OK);
ExecSqliteConfig(aPerfTestMode);
sprintf(tmp, "%d", aSelectRecId);
strcpy(TheSqlBuf2, aSingleSelectSql);
strcat(TheSqlBuf2, tmp);
err = sqlite3_prepare(TheDb2, TheSqlBuf2, -1, &stmt, &tail);
TEST2(err, SQLITE_OK);
fc = FastCounterValue();
while((err = sqlite3_step(stmt)) == SQLITE_ROW)
{
__int64 i64;
double d;
const unsigned short* t;
const unsigned char* b;
i64 = sqlite3_column_int64(stmt, 0);
UNUSED_VAR(i64);
d = sqlite3_column_double(stmt, 1);
UNUSED_VAR(d);
t = (const unsigned short*)sqlite3_column_text16(stmt, 2);
UNUSED_VAR(t);
b = (const unsigned char*)sqlite3_column_blob(stmt, 3);
UNUSED_VAR(b);
++recCnt;
}
StorePerfTestResult(aPerfTestMode, EPerfTestSingleSelect, FastCounterValue() - fc);
TEST2(err, SQLITE_DONE);
TEST2(recCnt, 1);
sqlite3_finalize(stmt);
sqlite3_close(TheDb2);
TheDb2 = 0;
}
