Connection::Column_metadata Connection::table_column_metadata(const std::string & table_name, const std::string & column_name,
const std::string & db_name)
{
const char * type, * collation;
int not_null, primary_key, auto_inc;
int status = sqlite3_table_column_metadata(_db, db_name.c_str(), table_name.c_str(), column_name.c_str(),
&type, &collation, ¬_null, &primary_key, &auto_inc);
if(status != SQLITE_OK)
{
sqlite3_close(_db);
throw Runtime_error("Error getting column info (" +
db_name + "." + table_name + "." + column_name + "): " +
sqlite3_errmsg(_db), "", status, nullptr);
}
Column_metadata ret;
ret.type = type;
ret.collation = collation;
ret.not_null = bool(not_null);
ret.primary_key = bool(primary_key);
ret.auto_inc = bool(auto_inc);
return ret;
}
int column_metadata_helper(
sqlite3 *db,
sqlite3_stmt *stmt,
int col,
struct metadata *p
){
const char *zTableName, *zColumnName;
int rc = 0;
p->pNotNull = 0;
p->pPrimaryKey = 0;
p->pAutoinc = 0;
zTableName = sqlite3_column_table_name(stmt, col);
zColumnName = sqlite3_column_name(stmt, col);
if (zTableName && zColumnName) {
rc = sqlite3_table_column_metadata(
db, 0, zTableName, zColumnName, 0, 0,
&p->pNotNull, &p->pPrimaryKey, &p->pAutoinc
);
}
return rc;
}
__declspec(dllexport) int WINAPI sqlite3_table_column_metadata_interop(sqlite3 *db, const char *zDbName, const char *zTableName, const char *zColumnName, char **pzDataType, char **pzCollSeq, int *pNotNull, int *pPrimaryKey, int *pAutoinc, int *pdtLen, int *pcsLen)
{
int n;
n = sqlite3_table_column_metadata(db, zDbName, zTableName, zColumnName, pzDataType, pzCollSeq, pNotNull, pPrimaryKey, pAutoinc);
*pdtLen = (*pzDataType != 0) ? strlen(*pzDataType) : 0;
*pcsLen = (*pzCollSeq != 0) ? strlen(*pzCollSeq) : 0;
return n;
}
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
}
}
bool Handle::isTableExists(const std::string &tableName)
{
int rc = sqlite3_table_column_metadata((sqlite3 *) m_handle, nullptr,
tableName.c_str(), nullptr, nullptr,
nullptr, nullptr, nullptr, nullptr);
if (rc == SQLITE_OK) {
m_error.reset();
return true;
}
if (rc == SQLITE_ERROR) {
m_error.reset();
return false;
}
Error::ReportSQLite(m_tag, path, Error::HandleOperation::IsTableExists, rc,
sqlite3_extended_errcode((sqlite3 *) m_handle),
sqlite3_errmsg((sqlite3 *) m_handle), &m_error);
return false;
}
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));
}
