std::string SQLiteResultSetMetaData::getTableName(unsigned int column) {
const char *cptr="";
if(sqlite3_compileoption_used("SQLITE_ENABLE_COLUMN_METADATA"))
cptr=sqlite3_column_origin_name(getSQLiteStatement()->stmt,column);
return cptr;
}
Utf8StringVector SqliteStatement::columnNames() const
{
Utf8StringVector columnNames;
int columnCount = SqliteStatement::columnCount();
columnNames.reserve(columnCount);
for (int columnIndex = 0; columnIndex < columnCount; columnIndex++)
columnNames.append(Utf8String(sqlite3_column_origin_name(compiledStatement.get(), columnIndex), -1));
return columnNames;
}
SWIGEXPORT jstring JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1column_1origin_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
jstring jresult = 0 ;
sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ;
int arg2 ;
char *result = 0 ;
(void)jenv;
(void)jcls;
arg1 = *(sqlite3_stmt **)&jarg1;
arg2 = (int)jarg2;
result = (char *)sqlite3_column_origin_name(arg1,arg2);
if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
return jresult;
}
static int sqlite3_odbx_column_type( odbx_result_t* result, unsigned long pos )
{
#ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA
const char *type, *collation;
int notnull, primarykey, autoinc;
#endif
switch( sqlite3_column_type( (sqlite3_stmt*) result->generic, pos ) )
{
case SQLITE_INTEGER:
return ODBX_TYPE_BIGINT;
case SQLITE_FLOAT:
return ODBX_TYPE_DOUBLE;
case SQLITE_BLOB:
return ODBX_TYPE_BLOB;
case SQLITE_TEXT:
return ODBX_TYPE_CLOB;
default:
#ifdef HAVE_SQLITE3_TABLE_COLUMN_METADATA
if( sqlite3_table_column_metadata( (sqlite3*) result->handle->generic,
sqlite3_column_database_name( (sqlite3_stmt*) result->generic, pos ),
sqlite3_column_table_name( (sqlite3_stmt*) result->generic, pos ),
sqlite3_column_origin_name( (sqlite3_stmt*) result->generic, pos ),
&type, &collation, ¬null, &primarykey, &autoinc ) != SQLITE_OK )
{
return ODBX_TYPE_UNKNOWN;
}
if( strstr( type, "DOUBLE" ) != NULL || strcmp( type, "FLOAT" ) == 0 || strcmp( type, "REAL" ) == 0 ) {
return ODBX_TYPE_DOUBLE;
} else if( strstr( type, "INT" ) != NULL || strcmp( type, "BOOLEAN" ) == 0 ) {
return ODBX_TYPE_BIGINT;
} else if( strstr( type, "CHAR" ) != NULL || strcmp( type, "CLOB" ) == 0 || strcmp( type, "TEXT" ) == 0 ) {
return ODBX_TYPE_CLOB;
} else if( strstr( type, "DATE" ) != NULL || strstr( type, "TIME" ) != NULL || strstr( type, "DECIMAL" ) != NULL ) {
return ODBX_TYPE_CLOB;
} else if( strcmp( type, "BLOB" ) == 0 ) {
return ODBX_TYPE_BLOB;
} else {
return ODBX_TYPE_UNKNOWN;
}
#else
return ODBX_TYPE_UNKNOWN;
#endif
}
}
jstring JNICALL Java_com_baidu_javalite_PrepareStmt_sqlite3_1column_1origin_1name(
JNIEnv *env, jclass cls, jlong handle, jint column)
{
if (handle == 0)
{
throwSqliteException(env, "handle is NULL");
return 0;
}
sqlite3_stmt* stmt = (sqlite3_stmt*) handle;
const char* cn = sqlite3_column_origin_name(stmt, column);
if (cn == 0)
{
return (*env)->NewStringUTF(env, "");
} else
{
return (*env)->NewStringUTF(env, cn);
}
}
ECode CStmt::ColumnOriginName(
/* [in] */ Int32 col,
/* [out] */ String* str)
{
VALIDATE_NOT_NULL(str);
#if HAVE_SQLITE3 && HAVE_SQLITE3_COLUMN_ORIGIN_NAME16
hvm *v = (hvm *)mHandle;
if (v && v->vm && v->h) {
Int32 ncol = sqlite3_column_count((sqlite3_stmt *) v->vm);
const char *strchar;
if (col < 0 || col >= ncol) {
*str = String(NULL);
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
strchar = sqlite3_column_origin_name((sqlite3_stmt *) v->vm, col);
if (strchar) {
*str = String(strchar));
}
} else {
list<shared_ptr<SqlRecord>> SqlHelper::selectRec(sqlite3 *db,
string tbl, list<shared_ptr<SqlValue>> where) {
string sql;
list<shared_ptr<SqlRecord>> nullRec;
sql = "SELECT * from " + tbl;
if(where.empty()) {
sql += ";";
} else {
sql += " where ";
for (list<shared_ptr<SqlValue>>::iterator it = where.begin();
it != where.end(); it++) {
if((*it)->getType() == SQL_TEXT) {
shared_ptr<SqlString> value = dynamic_pointer_cast<SqlString>(*it);
if(distance(where.begin(), it) != 0) sql += " and ";
sql += value->getKey() + "=\"" + value->getData() + "\"";
}
}
}
sqlite3_stmt *stmt;
int rc = sqlite3_prepare_v2(db, sql.c_str(), sql.length() + 1, &stmt, NULL);
if( rc!=SQLITE_OK ){
printf("Failed to prepare(%s) sql : %s\n",
sqlite3_errmsg(db), sql.c_str());
return nullRec;
}
list<shared_ptr<SqlRecord>> result;
while (1) {
int s;
s = sqlite3_step (stmt);
if (s == SQLITE_ROW) {
shared_ptr<SqlRecord> rec(new SqlRecord());
const char *tmp;
int colCnt = sqlite3_column_count(stmt);
for(int i=0; i<colCnt ; i++) {
switch (sqlite3_column_type(stmt, i)) {
case SQLITE_INTEGER:
// printf("integer value[%d] : name[%s] val[%d]\n", i,
// sqlite3_column_origin_name(stmt, i),
// sqlite3_column_int(stmt, i));
rec->push(shared_ptr<SqlInteger>(
new SqlInteger(
sqlite3_column_origin_name(stmt, i),
sqlite3_column_int(stmt, i)
)));
break;
case SQLITE_TEXT:
// printf("text value[%d] : name[%s] val[%s]\n", i,
// sqlite3_column_origin_name(stmt, i),
// sqlite3_column_text(stmt, i));
rec->push(shared_ptr<SqlString>(
new SqlString(
sqlite3_column_origin_name(stmt, i),
(const char *)sqlite3_column_text(stmt, i)
)));
break;
case SQLITE_BLOB:
/*Write to a file, dynamic memory ...*/
break;
}
}
result.push_back(rec);
} else if (s == SQLITE_DONE)
break;
else {
printf("Failed.\n");
sqlite3_finalize(stmt);
return nullRec;
}
}
sqlite3_finalize(stmt);
return result;
}
void sqlite_source::prepare_data(
const std::string & database_name,
const std::string & sql)
throw(
std::logic_error,
std::invalid_argument)
{
check_not_running();
delete_data();
sqlite3_stmt* data = get_stmt(database_name, sql);
int column_count = sqlite3_column_count(data);
if (column_count == 0) //statement is no SELECT statement
{
throw std::invalid_argument("Statement is no SQL SELECT statement.");
}
m_data = data;
m_column_count = column_count;
m_time_column = sqlite3_bind_parameter_index(m_data, get_duration_string().c_str());
m_database_name = database_name;
m_sql = sql;
std::vector<column_info> column_infos;
sqlite3* db_handle = sqlite3_db_handle(m_data);
char const* data_type = NULL;
char const* coll_seq = NULL;
int not_null = 0;
int primary_key = 0;
int auto_inc = 0;
for (int i = 0; i < m_column_count; ++i)
{
std::string column_name = sqlite3_column_origin_name(m_data, i);
int result_code = sqlite3_table_column_metadata(
db_handle,
sqlite3_column_database_name(m_data, i),
sqlite3_column_table_name(m_data, i),
column_name.c_str(),
&data_type,
&coll_seq,
¬_null,
&primary_key,
&auto_inc);
if (result_code != SQLITE_OK)
{
//TODO: do something with the error...this error can only be an internal db error
}
if (i + 1 != m_time_column)
{
std::string type(data_type);
column_info info(column_name, m_source_name, get_data_type(data_type));
column_infos.push_back(info);
}
}
m_stream_schema = stream_schema_ptr(new stream_schema(m_source_name, column_infos));
}
std::string Column::getOriginName() const throw () {
return sqlite3_column_origin_name(m_Statement.statement.get(), m_index);
}
//----------------------------------------------------------------//
cc8* USSqlStatement::GetColumnName ( u32 iCol ) {
assert ( this->mStatement );
return sqlite3_column_origin_name ( this->mStatement, iCol );
}
// Return the name of the table column that is the origin of this result column
const char* Column::getOriginName() const noexcept // nothrow
{
return sqlite3_column_origin_name(mStmtPtr, mIndex);
}
__declspec(dllexport) const char * WINAPI sqlite3_column_origin_name_interop(sqlite3_stmt *stmt, int iCol, int *plen)
{
const char *pval = sqlite3_column_origin_name(stmt, iCol);
*plen = (pval != 0) ? strlen(pval) : 0;
return pval;
}
const char* Database::Query::getOriginName(int column)
{
return _stmt ? sqlite3_column_origin_name(_stmt, column) : "";
}
// Return the named assigned to the specified result column (potentially aliased)
const char* Statement::getColumnOriginName(const int aIndex) const
{
checkIndex(aIndex);
return sqlite3_column_origin_name(mStmtPtr, aIndex);
}
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);
}
