/**
request : 'db -> sql:string -> 'result
<doc>Executes the SQL request and returns its result</doc>
**/
HL_PRIM sqlite_result *HL_NAME(request)(sqlite_database *db, vbyte *sql ) {
sqlite_result *r;
const char *tl;
int i,j;
r = (sqlite_result*)hl_gc_alloc_finalizer(sizeof(sqlite_result));
r->finalize = HL_NAME(finalize_result);
r->db = db;
if( sqlite3_prepare16_v2(db->db, sql, -1, &r->r, &tl) != SQLITE_OK ) {
HL_NAME(error)(db->db, false);
}
if( *tl ) {
sqlite3_finalize(r->r);
hl_error("SQLite error: Cannot execute several SQL requests at the same time");
}
r->ncols = sqlite3_column_count(r->r);
r->names = (int*)hl_gc_alloc(sizeof(int)*r->ncols);
r->bools = (int*)hl_gc_alloc(sizeof(int)*r->ncols);
r->first = 1;
r->done = 0;
for(i=0;i<r->ncols;i++) {
int id = hl_hash_gen((uchar*)sqlite3_column_name16(r->r,i), true);
const char *dtype = sqlite3_column_decltype(r->r,i);
for(j=0;j<i;j++)
if( r->names[j] == id ) {
if( strcmp(sqlite3_column_name16(r->r,i), sqlite3_column_name16(r->r,j)) == 0 ) {
sqlite3_finalize(r->r);
hl_buffer *b = hl_alloc_buffer();
hl_buffer_str(b, USTR("SQLite error: Same field is two times in the request: "));
hl_buffer_str(b, (uchar*)sql);
hl_error_msg(hl_buffer_content(b, NULL));
} else {
hl_buffer *b = hl_alloc_buffer();
hl_buffer_str(b, USTR("SQLite error: Same field ids for: "));
hl_buffer_str(b, sqlite3_column_name16(r->r,i));
hl_buffer_str(b, USTR(" and "));
hl_buffer_str(b, sqlite3_column_name16(r->r,j));
sqlite3_finalize(r->r);
hl_error_msg(hl_buffer_content(b, NULL));
}
}
r->names[i] = id;
r->bools[i] = dtype?(strcmp(dtype,"BOOL") == 0):0;
}
// changes in an update/delete
if( db->last != NULL )
HL_NAME(finalize_request)(db->last, false);
db->last = r;
return db->last;
}
void SQLiteResultPrivate::initColumns(bool emptyResultset)
{
int nCols = sqlite3_column_count(stmt);
if (nCols <= 0)
return;
q->init(nCols);
for (int i = 0; i < nCols; ++i) {
QString colName = stringFromUnicode(reinterpret_cast<const QChar *>(
sqlite3_column_name16(stmt, i))
).remove(QLatin1Char('"'));
// must use typeName for resolving the type to match SQLiteDriver::record
QString typeName = stringFromUnicode(reinterpret_cast<const QChar *>(
sqlite3_column_decltype16(stmt, i)));
int dotIdx = colName.lastIndexOf(QLatin1Char('.'));
QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), qGetColumnType(typeName));
// sqlite3_column_type is documented to have undefined behavior if the result set is empty
int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);
fld.setSqlType(stp);
rInf.append(fld);
}
}
int CppSQLite3Query::fieldIndex(const TCHAR* szField)
{
checkVM();
if (szField)
{
for (int nField = 0; nField < mnCols; nField++)
{
#ifdef _UNICODE
const TCHAR* szTemp = (const TCHAR*)sqlite3_column_name16(mpVM, nField);
#else
const TCHAR* szTemp = sqlite3_column_name(mpVM, nField);
#endif
if(STRCMP(szField, szTemp) == 0)
{
return nField;
}
}
}
throw CppSQLite3Exception(CPPSQLITE_ERROR,
_T("Invalid field name requested"),
DONT_DELETE_MSG);
}
// 获取某列的名称
LPCTSTR SQLiteDataReader::GetName(int nCol)
{
#ifdef UNICODE
return (LPCTSTR)sqlite3_column_name16(m_pStmt, nCol);
#else
return (LPCTSTR)sqlite3_column_name(m_pStmt, nCol);
#endif
}
DBString fieldName() const
{
#ifdef DB_UTF16
return (const wchar_t*)sqlite3_column_name16(_stmt, _fieldIndex);
#else
return sqlite3_column_name(_stmt, _fieldIndex);
#endif
}
void
O2DatDB::
get_column_names(sqlite3_stmt* stmt, wstrarray &cols)
{
int column_count = sqlite3_column_count(stmt);
for (int i = 0; i < column_count; i++) {
cols.push_back((wchar_t*)sqlite3_column_name16(stmt, i));
}
}
/**
result_get_fields : 'result -> array<string>
<doc>Returns the array of field names in the result.</doc>
**/
HL_PRIM varray *HL_NAME(result_get_fields)( sqlite_result *r ) {
varray *a = hl_alloc_array(&hlt_bytes, r->ncols);
int i;
for (i = 0; i < r->ncols; i++)
{
hl_aptr(a, vbyte*)[i] = (vbyte *)sqlite3_column_name16(r->r, i);
}
return a;
}
String SQLiteStatement::getColumnName(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_name16(m_statement, col)));
}
void QSQLiteResultPrivate::initColumns(bool emptyResultset)
{
int nCols = sqlite3_column_count(stmt);
if (nCols <= 0)
return;
q->init(nCols);
for (int i = 0; i < nCols; ++i) {
QString colName = QString(reinterpret_cast<const QChar *>(
sqlite3_column_name16(stmt, i))
).remove(QLatin1Char('"'));
// must use typeName for resolving the type to match QSqliteDriver::record
QString typeName = QString(reinterpret_cast<const QChar *>(
sqlite3_column_decltype16(stmt, i)));
// sqlite3_column_type is documented to have undefined behavior if the result set is empty
int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);
QVariant::Type fieldType;
if (!typeName.isEmpty()) {
fieldType = qGetColumnType(typeName);
} else {
// Get the proper type for the field based on stp value
switch (stp) {
case SQLITE_INTEGER:
fieldType = QVariant::Int;
break;
case SQLITE_FLOAT:
fieldType = QVariant::Double;
break;
case SQLITE_BLOB:
fieldType = QVariant::ByteArray;
break;
case SQLITE_TEXT:
fieldType = QVariant::String;
break;
case SQLITE_NULL:
default:
fieldType = QVariant::Invalid;
break;
}
}
int dotIdx = colName.lastIndexOf(QLatin1Char('.'));
QSqlField fld(colName.mid(dotIdx == -1 ? 0 : dotIdx + 1), fieldType);
fld.setSqlType(stp);
rInf.append(fld);
}
}
static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jlong connectionPtr,
jlong statementPtr, jint index) {
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
const jchar* name = static_cast<const jchar*>(sqlite3_column_name16(statement, index));
if (name) {
size_t length = 0;
while (name[length]) {
length += 1;
}
return env->NewString(name, length);
}
return NULL;
}
const TCHAR* CppSQLite3Query::fieldName(int nCol)
{
checkVM();
if (nCol < 0 || nCol > mnCols-1)
{
throw CppSQLite3Exception(CPPSQLITE_ERROR,
_T("Invalid field index requested"),
DONT_DELETE_MSG);
}
#ifdef _UNICODE
return (const TCHAR*)sqlite3_column_name16(mpVM, nCol);
#else
return sqlite3_column_name(mpVM, nCol);
#endif
}
void Session::_MapResultColumnsToObject(ObjectBase *oPtr, sqlite3_stmt *statement)
{
int cols = sqlite3_column_count(statement);
TCHAR *column_name;
CString *pCString;
for(int x = 0; x < cols; ++x)
{
#ifdef UNICODE
column_name = (TCHAR*)sqlite3_column_name16(statement, x);
#else
column_name = sqlite3_column_name(statement, x);
#endif
if(!oPtr->GetMap().count(column_name))
{
return;
}
VarInfo p(oPtr->GetMap().find(column_name)->second);
switch(p.type)
{
case VarInfo::STRING:
pCString = reinterpret_cast<CString*>(p.dataPtr);
#ifdef UNICODE
pCString->Format(_T("%s"),(TCHAR*)sqlite3_column_text16(statement, x));
#else
pCString->Format(_T("%s"),(TCHAR*)sqlite3_column_text(statement, x));
#endif
break;
case VarInfo::INT:
*((int*)p.dataPtr) = sqlite3_column_int(statement, x);
break;
case VarInfo::INT64:
*((__int64*)p.dataPtr) = sqlite3_column_int64(statement, x);
break;
case VarInfo::DOUBLE:
*((double*)p.dataPtr) = sqlite3_column_double(statement, x);
break;
}
}
oPtr->m_is_null = false;
}
std::wstring sqlite3_reader::getcolname16(int index) {
check_reader(index);
return (const wchar_t*)sqlite3_column_name16(this->cmd->stmt, index);
}
static void DoTestStatement()
{
int err, val;
sqlite_int64 val64;
double dblval;
const unsigned char* textval;
const unsigned short* textval16;
const unsigned char* blob;
const char *coltype, *colname;
const unsigned short *coltype16, *colname16;
sqlite3* db;
TEST(TheDb != 0);
TEST(TheStmt != 0);
val = sqlite3_column_count(TheStmt);
TEST2(val, 5);
db = sqlite3_db_handle(TheStmt);
TEST2((unsigned int)db, (unsigned int)TheDb);
err = sqlite3_step(TheStmt);
TEST2(err, SQLITE_ROW);
#ifdef SQLITE_ENABLE_COLUMN_METADATA
sqlite3_column_database_name(TheStmt, 0);
sqlite3_column_database_name16(TheStmt, 1);
sqlite3_column_table_name(TheStmt, 2);
sqlite3_column_table_name16(TheStmt, 3);
sqlite3_column_origin_name(TheStmt, 4);
sqlite3_column_origin_name16(TheStmt, 0);
#endif
coltype = sqlite3_column_decltype(TheStmt, 0);
TEST2(strcmp(coltype, "INTEGER"), 0);
coltype16 = (const unsigned short*)sqlite3_column_decltype16(TheStmt, 2);
TEST2(wcscmp(coltype16, L"REAL"), 0);
colname = sqlite3_column_name(TheStmt, 1);
TEST2(strcmp(colname, "F2"), 0);
colname16 = (const unsigned short *)sqlite3_column_name16(TheStmt, 4);
TEST2(wcscmp(colname16, L"F5"), 0);
val = sqlite3_column_int(TheStmt, 0);
TEST2(val, 1);
val64 = sqlite3_column_int64(TheStmt, 1);
TEST64(val64, 1234567891234LL);
dblval = sqlite3_column_double(TheStmt, 2);
TEST(dabs(dblval - 56.12) < 0.00001);
textval = sqlite3_column_text(TheStmt, 3);
TEST2(strcmp((const char*)textval, "TEXT"), 0);
textval16 = sqlite3_column_text16(TheStmt, 3);
TEST2(wcscmp(textval16, L"TEXT"), 0);
blob = (const unsigned char*)sqlite3_column_blob(TheStmt, 4);
TEST2(memcmp(blob, "123456", 6), 0);
err = sqlite3_step(TheStmt);
TEST2(err, SQLITE_DONE);
}
__declspec(dllexport) const void * WINAPI sqlite3_column_name16_interop(sqlite3_stmt *stmt, int iCol, int *plen)
{
const void *pval = sqlite3_column_name16(stmt, iCol);
*plen = (pval != 0) ? wcslen((wchar_t *)pval) * sizeof(wchar_t) : 0;
return pval;
}
std::wstring sqlite3_cursor::getcolname16(int index) {
READER_CHECK(wstring);
return (const wchar_t*)sqlite3_column_name16(this->cmd->stmt, index);
}
int sqlite3_exec_utf16(sqlite3 *db,
const WCHAR *zSql,
sqlite3_callback_utf16 xCallback,
void *pArg,
BindHandle * bind)
{
int rc = SQLITE_OK;
const WCHAR *zLeftover;
sqlite3_stmt *pStmt = 0;
WCHAR **azCols = 0;
int nRetry = 0;
int nCallback;
if (zSql==0)
{
return SQLITE_OK;
}
while((rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0])
{
int nCol;
WCHAR **azVals = 0;
pStmt = 0;
rc = sqlite3_prepare16(db, zSql, -1, &pStmt, (const void **) &zLeftover);
if (rc!=SQLITE_OK)
{
continue;
}
if(!pStmt)
{
zSql = zLeftover;
continue;
}
if (bind)
{
for (int i = 0; i < (int)bind->BindObjects.size(); i ++)
{
switch (bind->BindObjects[i].Type)
{
case typeString:
sqlite3_bind_text16(pStmt, i + 1, (void*) bind->BindObjects[i].String, -1, SQLITE_TRANSIENT);
break;
default:
sqlite3_bind_text16(pStmt, i + 1, (void*) L"(unknown type)", -1, SQLITE_TRANSIENT);
break;
}
}
}
nCallback = 0;
nCol = sqlite3_column_count(pStmt);
while (true)
{
int i;
rc = sqlite3_step(pStmt);
if (xCallback && (SQLITE_ROW==rc || (SQLITE_DONE==rc && !nCallback )))
{
if (0==nCallback)
{
if (azCols==0)
{
azCols = (WCHAR**) sqlite3_malloc(2*nCol*sizeof(const WCHAR*) + 1);
if (azCols==0)
{
goto exec_out;
}
}
for (i=0; i<nCol; i++)
{
azCols[i] = (WCHAR *)sqlite3_column_name16(pStmt, i);
}
nCallback++;
}
if (rc==SQLITE_ROW)
{
azVals = &azCols[nCol];
for (i=0; i<nCol; i++)
{
azVals[i] = (WCHAR *)sqlite3_column_text16(pStmt, i);
}
}
if (xCallback(pArg, nCol, azVals, azCols))
{
rc = SQLITE_ABORT;
goto exec_out;
}
}
if (rc!=SQLITE_ROW)
{
rc = sqlite3_finalize(pStmt);
pStmt = 0;
if (rc!=SQLITE_SCHEMA)
{
nRetry = 0;
zSql = zLeftover;
while (isspace((unsigned char)zSql[0]))
{
zSql++;
}
}
break;
}
}
sqlite3_free(azCols);
azCols = 0;
}
exec_out:
if (pStmt)
{
sqlite3_finalize(pStmt);
}
if (azCols)
{
sqlite3_free(azCols);
}
return rc;
}
