Ejemplo n.º 1
0
	bool Statement::GetInt(unsigned int Column, Nullable<int> &Out)
	{
		if (Inner == nullptr)
			return false;

		if (sqlite3_column_type(Inner, Column) == SQLITE_NULL)
		{
			Out = Nullable<int>();
			return true;
		}

		Out = Nullable<int>(sqlite3_column_int(Inner, Column));
		return true;
	}
Ejemplo n.º 2
0
	bool Statement::GetString(unsigned int Column, Nullable<std::string> &Out)
	{
		if (Inner == nullptr)
			return false;

		if (sqlite3_column_type(Inner, Column) == SQLITE_NULL)
		{
			Out = Nullable<std::string>();
			return true;
		}

		Out = Nullable<std::string>(std::string(reinterpret_cast<const char *>(sqlite3_column_text(Inner, Column))));
		return true;
	}
Ejemplo n.º 3
0
	void sqlite_table::retrieve_data(sqlite3_stmt* stmt)
	{
		tu_autolock locker(s_sqlite_plugin_mutex);

		int col_count = sqlite3_column_count(stmt);
		m_title.resize(col_count);
		for (int i = 0; i < col_count; i++)
		{
			m_title[i] = sqlite3_column_name(stmt, i);
		}
 
		int rc;
		do
		{
			as_object* row = new as_object(get_player());
			m_data.push_back(row);

			for (int i = 0; i < col_count; i++)
			{
				as_value val;
				int col_type = sqlite3_column_type(stmt, i);
				switch (col_type)
				{
					case SQLITE_INTEGER :
						val.set_int(sqlite3_column_int(stmt, i));
						break;
					case SQLITE_FLOAT :
						val.set_double(sqlite3_column_double(stmt, i));
						break;
					case SQLITE_BLOB :
// FIXME:						val.set_string((const char*) sqlite3_column_blob(stmt, i));
						break;
					case SQLITE_NULL :
//						val.set_null();
						val.set_string("");
						break;
					case SQLITE3_TEXT :
						val.set_string((const char*) sqlite3_column_text(stmt, i));
						break;
					default:
						assert(0);
						break;
				}
				row->set_member(m_title[i], val);
			}
			rc = sqlite3_step(stmt);
		}
		while (rc == SQLITE_ROW);
	}
Ejemplo n.º 4
0
Archivo: scache.c Proyecto: hyc/heimdal
static krb5_error_code KRB5_CALLCONV
scc_get_principal(krb5_context context,
		  krb5_ccache id,
		  krb5_principal *principal)
{
    krb5_scache *s = SCACHE(id);
    krb5_error_code ret;
    const char *str;

    *principal = NULL;

    ret = make_database(context, s);
    if (ret)
	return ret;

    sqlite3_bind_int(s->scache, 1, s->cid);

    if (sqlite3_step(s->scache) != SQLITE_ROW) {
	sqlite3_reset(s->scache);
	krb5_set_error_message(context, KRB5_CC_END,
			       N_("No principal for cache SCC:%s:%s", ""),
			       s->name, s->file);
	return KRB5_CC_END;
    }

    if (sqlite3_column_type(s->scache, 0) != SQLITE_TEXT) {
	sqlite3_reset(s->scache);
	krb5_set_error_message(context, KRB5_CC_END,
			       N_("Principal data of wrong type "
				  "for SCC:%s:%s", ""),
			       s->name, s->file);
	return KRB5_CC_END;
    }

    str = (const char *)sqlite3_column_text(s->scache, 0);
    if (str == NULL) {
	sqlite3_reset(s->scache);
	krb5_set_error_message(context, KRB5_CC_END,
			       N_("Principal not set for SCC:%s:%s", ""),
			       s->name, s->file);
	return KRB5_CC_END;
    }

    ret = krb5_parse_name(context, str, principal);

    sqlite3_reset(s->scache);

    return ret;
}
Ejemplo n.º 5
0
		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;
		}
Ejemplo n.º 6
0
void genGateKeeperApprovedAppRow(sqlite3_stmt* const stmt, Row& r) {
  for (int i = 0; i < sqlite3_column_count(stmt); i++) {
    auto column_name = std::string(sqlite3_column_name(stmt, i));
    auto column_type = sqlite3_column_type(stmt, i);
    if (column_type == SQLITE_TEXT) {
      auto value = sqlite3_column_text(stmt, i);
      if (value != nullptr) {
        r[column_name] = std::string(reinterpret_cast<const char*>(value));
      }
    } else if (column_type == SQLITE_FLOAT) {
      auto value = sqlite3_column_double(stmt, i);
      r[column_name] = DOUBLE(value);
    }
  }
}
Ejemplo n.º 7
0
void genPkgRow(sqlite3_stmt* stmt, Row& r) {
  for (int i = 0; i < sqlite3_column_count(stmt); i++) {
    auto column_name = std::string(sqlite3_column_name(stmt, i));
    auto column_type = sqlite3_column_type(stmt, i);
    if (column_type == SQLITE_TEXT) {
      auto value = sqlite3_column_text(stmt, i);
      if (value != nullptr) {
        r[column_name] = std::string((const char*)value);
      }
    } else if (column_type == SQLITE_INTEGER) {
      auto value = sqlite3_column_int(stmt, i);
      r[column_name] = INTEGER(value);
    }
  }
}
Ejemplo n.º 8
0
ResultSet::FieldType SQLiteResult::fieldType(int field)
{
	if (field>num_fields) throw FieldNotInResultSetException("%d",field);
	if (!stmt) throw NoResultException();
	if (last_res!=SQLITE_ROW) throw NoResultException();
	int type=sqlite3_column_type(stmt, field);
	switch (type) {
		case SQLITE_INTEGER: return ResultSet::TYPE_INTEGER;
		case SQLITE_FLOAT: return ResultSet::TYPE_FLOAT;
		case SQLITE_BLOB: return ResultSet::TYPE_BINARY;
		case SQLITE_NULL: return ResultSet::TYPE_INTEGER;
		case SQLITE_TEXT: return ResultSet::TYPE_STRING;
	}
	return ResultSet::TYPE_UNKNOWN;
}
QVariant QgsSpatiaLiteFeatureIterator::getFeatureAttribute( sqlite3_stmt* stmt, int ic, const QVariant::Type& type )
{
  if ( sqlite3_column_type( stmt, ic ) == SQLITE_INTEGER )
  {
    // INTEGER value
    return sqlite3_column_int( stmt, ic );
  }

  if ( sqlite3_column_type( stmt, ic ) == SQLITE_FLOAT )
  {
    // DOUBLE value
    return sqlite3_column_double( stmt, ic );
  }

  if ( sqlite3_column_type( stmt, ic ) == SQLITE_TEXT )
  {
    // TEXT value
    const char *txt = ( const char * ) sqlite3_column_text( stmt, ic );
    return QString::fromUtf8( txt );
  }

  // assuming NULL
  return QVariant( type );
}
Ejemplo n.º 10
0
void QSpatiaLiteResultPrivate::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::fromUtf16( (const ushort *) sqlite3_column_name16(stmt, i) ).remove(QLatin1Char('"'));

        // must use typeName for resolving the type to match QSqliteDriver::record
        QString typeName = QString::fromUtf16( (const ushort *) 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);
    }
}
Ejemplo n.º 11
0
char *cws_query2json (char *dbfile, char *stmt)
{
    int i;
    const char *aux;
    char *json;
    
    json_object *root;
    json_object *array;
    sqlite3 *db;
    sqlite3_stmt *pp;
    
    sqlite3_open (dbfile, &db);
    sqlite3_prepare (db, stmt, strlen (stmt), &pp, NULL); 
    array = json_object_new_array ();
    
    while (sqlite3_step (pp) == SQLITE_ROW)
    {
        int ncol = sqlite3_column_count (pp);
        json_object *row = json_object_new_object (); 
        for (i = 0; i < ncol; i++)
        {
            json_object *col = NULL;
            switch (sqlite3_column_type (pp, i))
            {
                case SQLITE_FLOAT :
                    col = json_object_new_double (sqlite3_column_double (pp, i));
                    break;
                case SQLITE_INTEGER : 
                    col = json_object_new_int (sqlite3_column_int (pp, i));
                    break;
                case SQLITE_TEXT : 
                    col = json_object_new_string ((char *) sqlite3_column_text (pp, i));
                    break;
            }
            json_object_object_add (row, sqlite3_column_name (pp, i), col);
        }
        json_object_array_add (array, row);
    }
    sqlite3_finalize (pp);
    sqlite3_close (db);
    root = json_object_new_object ();
    json_object_object_add (root, "records", array);
    aux = json_object_to_json_string (root);
    json = malloc (sizeof (char) * (strlen (aux) + 1));
    strcpy (json, aux);
    json_object_put (root);
    return json;
}
Ejemplo n.º 12
0
	/*
		Return the data type of a column
	*/
	Statement::Type StatementPrivate::dataType(unsigned int column) const {
		switch (sqlite3_column_type(stmt_, column)) {
		case SQLITE_INTEGER:
			return Statement::Type::Integer;
		case SQLITE_FLOAT:
			return Statement::Type::Real;
		case SQLITE_BLOB:
			return Statement::Type::Binary;
		case SQLITE_NULL:
			return Statement::Type::Null;
		case SQLITE_TEXT:
			return Statement::Type::Text;
		default:
			return Statement::Type::Null;
		};
	}
Ejemplo n.º 13
0
const char* wyResultSet::dataForColumnIndex(int columnIdx, size_t* outLen) {
	// check type
    if (sqlite3_column_type(m_statement->getStatement(), columnIdx) == SQLITE_NULL || (columnIdx < 0)) {
    	*outLen = 0;
        return NULL;
    }

    // copy data
    int dataSize = sqlite3_column_bytes(m_statement->getStatement(), columnIdx);
    char* buf = (char*)wyMalloc(dataSize * sizeof(char));
    memcpy(buf, sqlite3_column_blob(m_statement->getStatement(), columnIdx), dataSize);

    // return buffer
    *outLen = dataSize;
    return (const char*)buf;
}
Ejemplo n.º 14
0
 query_result run(sqlite3_stmt *stmt) {
     query_result data(new Result);
     int rc;
     do {
         rc=sqlite3_step(stmt);
         if (rc==SQLITE_ROW) {
             data->resize(data->size()+1);
             rowResult cur=data->back();
             int nrows=sqlite3_column_count(stmt);
             for (int i=0;i<nrows;++i) {
                 LOCK_COUT
                 cout << "[DB] query " << stmt
                           << ": result row " << i+1 << "/" << nrows
                           << endl;
                 UNLOCK_COUT
                 switch (sqlite3_column_type(stmt,i)) {
                 case SQLITE_NULL:
                     cur[i]=dbValue::ptr(new dbValue);
                     break;
                 case SQLITE_INTEGER:
                     cur[i]=dbValue::ptr(new dbValue((s64)sqlite3_column_int(stmt,i)));
                     break;
                 case SQLITE_FLOAT:
                     cur[i]=dbValue::ptr(new dbValue((double)sqlite3_column_double(stmt,i)));
                     break;
                 case SQLITE_TEXT:
                     cur[i]=dbValue::ptr(new dbValue((const char *)sqlite3_column_text(stmt,i)));
                     break;
                 case SQLITE_BLOB:
                     cur[i]=dbValue::ptr(
                         new dbValue(
                             (const char *)sqlite3_column_text(stmt,i),
                             sqlite3_column_bytes(stmt,i)
                         ));
                     break;
                 }
             }
         }
     } while (rc==SQLITE_ROW);
     if (rc!=SQLITE_DONE) {
         DBError::busy_aware_throw(rc,sqlite3_errmsg(db));
     }
     LOCK_COUT
     cout << "[DB] " << stmt << ": " << data->size() << " rows returned." << endl;
     UNLOCK_COUT
     return data;
 }
Ejemplo n.º 15
0
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, &notnull, &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
	}
}
Ejemplo n.º 16
0
shared_ptr<DBValue> SQLiteDataReader::makeDBValue(sqlite3_stmt *statement, std::size_t column) {
    if (column >= (std::size_t) sqlite3_column_count(statement)) {
        return 0;
    }
    const int type = sqlite3_column_type(statement, column);
    switch (type) {
    case SQLITE_INTEGER:
        return new DBIntValue(sqlite3_column_int(statement, column));
    case SQLITE_FLOAT:
        return new DBRealValue(sqlite3_column_double(statement, column));
    case SQLITE_TEXT:
        return new DBTextValue((const char *) sqlite3_column_text(statement, column));
    case SQLITE_NULL:
        return DBValue::create(DBValue::DBNULL);
    }
    return 0;
}
Ejemplo n.º 17
0
void Query::ViewRes()
{
	if (!res)
	{
		printf("no result stored\n");
		return;
	}
	printf("result column count = %d\n", sqlite3_column_count(res));
	for (int i = 0; i < sqlite3_column_count(res); i++)
	{
		printf(" %2d   type %d   name '%s'", i, sqlite3_column_type(res, i), sqlite3_column_name(res, i));
		printf("  / '%s'", (char *)sqlite3_column_text(res, i));
		printf("  / %d", sqlite3_column_int(res, i));
		printf("  / %f", sqlite3_column_double(res, i));
		printf("\n");
	}
}
Ejemplo n.º 18
0
static pse_op_error_t sqlite_query_int_value(sqlite3 *db, const char* sql_sentence, int* value)
{
    pse_op_error_t ret = OP_SUCCESS;
    int rc;
    sqlite3_stmt *stat = NULL;

    rc = sqlite3_prepare_v2(db, sql_sentence, -1, &stat, 0);
    if(SQLITE_OK != rc)
    {
        ret = OP_ERROR_SQLITE_INTERNAL;
        goto exit;
    }

    rc = sqlite3_step(stat);
    if (SQLITE_DONE == rc)
    {
        *value = 0;
		ret = OP_ERROR_SQLITE_NOT_FOUND;
        goto exit;
    }
    if(SQLITE_ROW != rc)
    {
        ret = OP_ERROR_SQLITE_INTERNAL;
        goto exit;
    }

    rc = sqlite3_column_type(stat, 0);
    if(SQLITE_INTEGER != rc)
    {
        if(SQLITE_NULL == rc)
        {
            ret = OP_ERROR_SQLITE_NOT_FOUND; // SQlite returned a NULL record that indicates "NOT FOUND"
        }
        else
        {
            ret = OP_ERROR_INVALID_VMC_DB; // this will trigger DB re-initialization
        }
        goto exit;
    }

    *value = sqlite3_column_int(stat, 0);

exit:
    sqlite3_finalize(stat); 
    return ret;
}
Ejemplo n.º 19
0
/* --------------------------------------------------------------- */
void R_sqlget( const int func )
{
	int col, bytes;

	if (ARGN==0) {
		Licpy(ARGR, sqlite3_column_count(sqlstmt));
		return;
	}
	if (ARGN>1) Lerror(ERR_INCORRECT_CALL,0);
	get_i0(1,col);
	col--;

	switch (sqlite3_column_type(sqlstmt, col)) {
		case SQLITE_INTEGER:
			Licpy(ARGR, sqlite3_column_int(sqlstmt, col));
			break;

		case SQLITE_FLOAT:
			Lrcpy(ARGR, sqlite3_column_double(sqlstmt, col));
			break;

		case SQLITE_TEXT:
			Lscpy(ARGR, (char*)sqlite3_column_text(sqlstmt, col));
			break;

		case SQLITE_BLOB:
			bytes = sqlite3_column_bytes(sqlstmt, col);
			Lfx(ARGR, bytes);
			LLEN(*ARGR) = bytes;
			LTYPE(*ARGR) = LSTRING_TY;
			MEMCPY(LSTR(*ARGR), sqlite3_column_blob(sqlstmt, col), bytes);
			break;

		case SQLITE_NULL:
			Lfx(ARGR,1);
			LTYPE(*ARGR)   = LSTRING_TY;
			LLEN(*ARGR)    = 1;
			LSTR(*ARGR)[0] = 0;
			break;

		default:
			Lfx(ARGR,0);
			LTYPE(*ARGR) = LSTRING_TY;
			LLEN(*ARGR)  = 0;
	}
} /* R_sqlget */
Ejemplo n.º 20
0
const CommonCardData* ClientDatabase::getCardData(CardId id)
{
	auto found = _cards.find(id);

	if(found == _cards.end()) // not found: create and return
	{
		sqlite3_reset(_getCardStmt);
		sqliteThrowExcept(sqlite3_bind_int64(_getCardStmt, 1, id));

		assert(sqliteThrowExcept(sqlite3_step(_getCardStmt)) == SQLITE_ROW);

		CommonCardData * cardData;

		if(sqlite3_column_type(_getCardStmt, 4) == SQLITE_NULL)  // Spell
		{
			cardData = new ClientSpellData(
				id,
				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 0)),  // name
				sqlite3_column_int(_getCardStmt, 1),  // cost
				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 2))  // description
			);
		}
		else // Creature
		{
			cardData = new ClientCreatureData(
				id,
				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 0)),  // name
				sqlite3_column_int(_getCardStmt, 1),  // cost
				reinterpret_cast<const char *>(sqlite3_column_text(_getCardStmt, 2)),  // description
				sqlite3_column_int(_getCardStmt, 3),  // attack
				sqlite3_column_int(_getCardStmt, 4),  // health
				sqlite3_column_int(_getCardStmt, 5),  // shield
				sqlite3_column_int(_getCardStmt, 6)  // shieldType
			);
		}

		return _cards.emplace(std::make_pair<>(
		                          id,
		                          std::unique_ptr<CommonCardData>(cardData)
		                      )).first->second.get();
	}
	else // card already created
	{
		return found->second.get();
	}
}
Ejemplo n.º 21
0
 void Experiment::deserialize(sqlite3* db) {
     sqlite3_stmt *read;
     db_prepare(db, read, boost::format("select "
         "name, "
         "paramset_id, "
         "response_id, "
         "train_set, "
         "test_set, "
         "time, "
         "vcs_commit, "
         "human_note, "
         "machine_note, "
         "batch, "
         "skip, " 
         "flags " 
         "from experiment where id=%d;") % id);
     db_step(read, SQLITE_ROW);
     int c = 0; 
     name = string((const char*) sqlite3_column_text(read, c++));
     paramset.id = sqlite3_column_int64(read, c++);
     has_run = (sqlite3_column_type(read, c) != SQLITE_NULL);
     if (has_run) {
         response.id = sqlite3_column_int64(read, c++);
     } else {
         response.id = -1;
         c++;
     }
     train_set = string((const char*) sqlite3_column_text(read, c++));
     test_set = string((const char*) sqlite3_column_text(read, c++));
     if (has_run) {
         time = string((const char*) sqlite3_column_text(read, c++));
         vcs_commit = string((const char*) sqlite3_column_text(read, c++));
     } else {
         c += 2;
     }
     human_note = string((const char*) sqlite3_column_text(read, c++));
     machine_note = string((const char*) sqlite3_column_text(read, c++));
     batch = string((const char*) sqlite3_column_text(read, c++));
     skip = sqlite3_column_int(read, c++) != 0;
     flags = sqlite3_column_int(read, c++);
     sqlite3_finalize(read);
     paramset.deserialize(db);
     if (has_run) {
         response.deserialize(db);
     }
 }
Ejemplo n.º 22
0
LJEntry*
journal_store_get_entry(JournalStore *js, int get_itemid) {
	LJEntry *entry;
	sqlite3_stmt *stmt = NULL;
	int ret;
	time_t timestamp;

	SQLCHECK(sqlite3_prepare(js->db,
		"SELECT anum, subject, event, moodid, mood, " /* 0-4 */
		"music, pickeyword, preformatted, backdated, " /* 5-9 */ 
		"comments, timestamp, security, taglist " /* 10-13 */
		"FROM entry WHERE itemid=?1",
		-1, &stmt, NULL));
	SQLCHECK(sqlite3_bind_int(stmt, 1, get_itemid));

	ret = sqlite3_step(stmt);
	if (ret != SQLITE_ROW) {
		SQLCHECK(sqlite3_finalize(stmt));
		return NULL;
	}

	entry = lj_entry_new();
	entry->itemid = get_itemid;
	entry->anum = sqlite3_column_int(stmt, 0);
	entry->subject = dup_col_or_null(stmt, 1);
	entry->event = dup_col_or_null(stmt, 2);
	entry->moodid = sqlite3_column_int(stmt, 3);
	entry->mood = dup_col_or_null(stmt, 4);

	entry->music = dup_col_or_null(stmt, 5);
	entry->pickeyword = dup_col_or_null(stmt, 6);
	entry->preformatted = sqlite3_column_int(stmt, 7);
	entry->backdated = sqlite3_column_int(stmt, 8);
	entry->comments = sqlite3_column_int(stmt, 9);
	entry->taglist = dup_col_or_null(stmt, 12);

	timestamp = sqlite3_column_int(stmt, 10);
	gmtime_r(&timestamp, &entry->time);

	if (sqlite3_column_type(stmt, 11) != SQLITE_NULL)
		security_from_int(&entry->security, sqlite3_column_int(stmt, 11));

	SQLCHECK(sqlite3_finalize(stmt));

	return entry;
}
Ejemplo n.º 23
0
mxArray *get_column(sqlite3_stmt *stmt, int index)
{
    int type = sqlite3_column_type(stmt, index);
    if (type == SQLITE_TEXT) {
        const char *text = sqlite3_column_text(stmt, index);
        return mxCreateCharMatrixFromStrings(1, &text);
    } else if (type == SQLITE_FLOAT) {
        return mxCreateDoubleScalar(sqlite3_column_double(stmt, index));
    } else if (type == SQLITE_INTEGER) {
        mxArray *a = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
        int64_t val = sqlite3_column_int64(stmt, index);
        memcpy(mxGetData(a), &val, sizeof val);
        return a;
    }
    mexErrMsgIdAndTxt("sqlite3:get_column", "unsupported column type");
    return NULL;
}
Ejemplo n.º 24
0
static JSBool
js_db_step(JSContext *cx, JSObject *obj, uintN argc,
           jsval *argv, jsval *rval)
{
    js_db_t *jd = JS_GetPrivate(cx, obj);

    if(js_db_check(cx, jd))
        return JS_FALSE;

    if(jd->jd_stmt == NULL) {
        *rval = JSVAL_NULL;
    } else if(jd->jd_step_rc == SQLITE_ROW) {
        int cols = sqlite3_data_count(jd->jd_stmt);
        int i;

        JSObject *r = JS_NewObjectWithGivenProto(cx, NULL, NULL, obj);
        *rval = OBJECT_TO_JSVAL(r);

        if(!JS_EnterLocalRootScope(cx))
            return JS_FALSE;

        for(i = 0; i < cols; i++) {

            const char *cn = sqlite3_column_name(jd->jd_stmt, i);

            switch(sqlite3_column_type(jd->jd_stmt, i)) {
            case SQLITE_INTEGER:
                js_set_prop_int(cx, r, cn, sqlite3_column_int(jd->jd_stmt, i));
                break;
            case SQLITE_TEXT:
                js_set_prop_str(cx, r, cn,
                                (const char *)sqlite3_column_text(jd->jd_stmt, i));
                break;
            case SQLITE_FLOAT:
                js_set_prop_dbl(cx, r, cn, sqlite3_column_double(jd->jd_stmt, i));
                break;
            }
        }
        JS_LeaveLocalRootScope(cx);

        return js_stmt_step(cx, jd, rval);
    }
    *rval = JSVAL_FALSE;
    return JS_TRUE;
}
/**
 * Fetch the current branch if attached.
 * Return NULL if detached.
 *
 */
void sg_wc_db__branch__get_branch(SG_context * pCtx,
                                  sg_wc_db * pDb,
                                  char ** ppszBranchName)
{
    sqlite3_stmt * pStmt = NULL;
    int rc;

    SG_ERR_CHECK(  sg_sqlite__prepare(pCtx, pDb->psql, &pStmt,
                                      ("SELECT"
                                       "    name"	// 0
                                       "  FROM tbl_branch"
                                       "  WHERE id = ?"))  );
    SG_ERR_CHECK(  sg_sqlite__bind_int64(pCtx, pStmt, 1, ID_KEY)  );
    rc = sqlite3_step(pStmt);
    switch (rc)
    {
    case SQLITE_ROW:
        if (sqlite3_column_type(pStmt, 0) == SQLITE_NULL)
            *ppszBranchName = NULL;
        else
            SG_ERR_CHECK(  SG_STRDUP(pCtx, (const char *)sqlite3_column_text(pStmt, 0), ppszBranchName)  );
        break;

    case SQLITE_DONE:
        *ppszBranchName = NULL;
        break;

    default:
        SG_ERR_THROW2(  SG_ERR_SQLITE(rc),
                        (pCtx, "sg_wc_db:tbl_branch can't get branch name.")  );
    }

    SG_ERR_CHECK(  sg_sqlite__nullfinalize(pCtx, &pStmt)  );

#if TRACE_WC_DB
    SG_ERR_IGNORE(  SG_console(pCtx, SG_CS_STDERR,
                               "sg_wc_db__branch__get_branch: %s\n",
                               ((*ppszBranchName) ? (*ppszBranchName) : "<detached>"))  );
#endif

    return;

fail:
    SG_ERR_IGNORE(  sg_sqlite__nullfinalize(pCtx, &pStmt)  );
}
Ejemplo n.º 26
0
EphySQLiteColumnType
ephy_sqlite_statement_get_column_type (EphySQLiteStatement *self, int column)
{
  int column_type = sqlite3_column_type (self->priv->prepared_statement, column);
  switch (column_type) {
    case SQLITE_INTEGER:
      return EPHY_SQLITE_COLUMN_TYPE_INT;
    case SQLITE_FLOAT:
      return EPHY_SQLITE_COLUMN_TYPE_FLOAT;
    case SQLITE_TEXT:
      return EPHY_SQLITE_COLUMN_TYPE_STRING;
    case SQLITE_BLOB:
      return EPHY_SQLITE_COLUMN_TYPE_BLOB;
    case SQLITE_NULL:
    default:
      return EPHY_SQLITE_COLUMN_TYPE_NULL;
  }
}
Ejemplo n.º 27
0
/* Static */
static gint
_highest_logged_session_id()
{
  gchar *cmd = NULL;
  sqlite3_stmt *stmt = NULL;
  gint id = 0;

  cmd = sqlite3_mprintf("select max(id) from sessionslog;");
  sqlite3_prepare(ccl->db, cmd, -1, &stmt, NULL);
  sqlite3_free(cmd);
  if (sqlite3_step(stmt) == SQLITE_ROW &&
      sqlite3_column_type(stmt, 0) != SQLITE_NULL)
    id = sqlite3_column_int(stmt, 0);
  
  sqlite3_finalize(stmt);

  return id;
}
Ejemplo n.º 28
0
static int fetch(lua_State* L, int mode) {
	stmt* s = (stmt*)luaL_checkudata(L, 1, MT_STMT);
	sqlite3* db = sqlite3_db_handle(s->handle);
	int ret;
	while((ret = sqlite3_step(s->handle)) == SQLITE_SCHEMA) {}
	if(ret == SQLITE_DONE) {
		lua_pushnil(L);
		return 1;
	} else if(ret == SQLITE_ROW) {
		int i;
		int col_count = sqlite3_column_count(s->handle);
		lua_createtable(L, col_count, 0);
		for(i = 0; i < col_count; i++) {

			if(mode == 0) {
				/* fetch, rows */
				lua_pushstring(L, sqlite3_column_name(s->handle, i));
			} else if(mode == 1) {
				/* ifetch, irows */
				lua_pushinteger(L, i + 1);
			}

			switch(sqlite3_column_type(s->handle, i)) {
			case SQLITE_INTEGER:
				lua_pushinteger(L, sqlite3_column_int(s->handle, i));
				break;
			case SQLITE_FLOAT:
				lua_pushnumber(L, sqlite3_column_double(s->handle, i));
				break;
			case SQLITE_TEXT:
				lua_pushstring(L, (const char*)sqlite3_column_text(s->handle, i));
				break;
			case SQLITE_BLOB:
			case SQLITE_NULL:
				lua_pushnil(L);
				break;
			}
			lua_settable(L, -3);
		}
		return 1;

	}
	return luaL_error(L, "[%d] %s", ret, sqlite3_errmsg(db));
}
Ejemplo n.º 29
0
gboolean
journal_store_scan(JournalStore *js,
                   JournalStoreScanCallback scan_cb,
                   const gpointer scan_data,
                   JournalStoreSummaryCallback cb_func,
                   const gpointer cb_data) {
	int ret;
	sqlite3_stmt *stmt = NULL;
	int matchcount = 0;

	SQLCHECK(sqlite3_prepare(js->db,
		"SELECT itemid, timestamp, subject, event, security "
		"FROM entry ORDER BY itemid ASC",
		-1, &stmt, NULL));

	ret = sqlite3_step(stmt);
	while (ret == SQLITE_ROW) {
		int itemid = sqlite3_column_int(stmt, 0);
		time_t timestamp = sqlite3_column_int(stmt, 1);
		const char *subject = (char*)sqlite3_column_text(stmt, 2);
		const char *event = (char*)sqlite3_column_text(stmt, 3);
		LJSecurity sec = {0};
		if (sqlite3_column_type(stmt, 4) != SQLITE_NULL)
			security_from_int(&sec, sqlite3_column_int(stmt, 4));

		if (scan_cb(subject, scan_data) || scan_cb(event, scan_data)) {
			const char *summary = lj_get_summary(subject, event);
			cb_func(itemid, timestamp, summary, &sec, cb_data);
			if (++matchcount == MAX_MATCHES)
				break;
		}
		ret = sqlite3_step(stmt);
	}

	if (ret != SQLITE_ROW && ret != SQLITE_DONE) {
		SQLCHECK(ret);
		SQLCHECK(sqlite3_finalize(stmt));
		return FALSE;
	}

	SQLCHECK(sqlite3_finalize(stmt));

	return TRUE;
}
Ejemplo n.º 30
0
QgsPolyline QgsOSMDatabase::wayPoints( QgsOSMId id ) const
{
  QgsPolyline points;

  // bind the way identifier
  sqlite3_bind_int64( mStmtWayNodePoints, 1, id );

  while ( sqlite3_step( mStmtWayNodePoints ) == SQLITE_ROW )
  {
    if ( sqlite3_column_type( mStmtWayNodePoints, 0 ) == SQLITE_NULL )
      return QgsPolyline(); // missing some nodes
    double lon = sqlite3_column_double( mStmtWayNodePoints, 0 );
    double lat = sqlite3_column_double( mStmtWayNodePoints, 1 );
    points.append( QgsPoint( lon, lat ) );
  }

  sqlite3_reset( mStmtWayNodePoints );
  return points;
}