#include <column_table.hpp>

Collaboration diagram for jubatus::core::storage::column_table:

Public Types
typedef std::pair< owner, uint64_t >	version_t

Public Member Functions
template<typename T1 >
bool	add (const std::string &key, const owner &o, const T1 &v1)

template<typename T1 , typename T2 >
bool	add (const std::string &key, const owner &o, const T1 &v1, const T2 &v2)

void	clear ()

	column_table ()

bool	delete_row (const std::string &target)

bool	delete_row (uint64_t index)

std::string	dump_json () const

std::pair< bool, uint64_t >	exact_match (const std::string &prefix) const

bit_vector_column &	get_bit_vector_column (size_t column_id)

const_bit_vector_column &	get_bit_vector_column (size_t column_id) const

version_t	get_clock (const std::string &target) const

version_t	get_clock (const uint64_t index) const

double_column &	get_double_column (size_t column_id)

const_double_column &	get_double_column (size_t column_id) const

float_column &	get_float_column (size_t column_id)

const_float_column &	get_float_column (size_t column_id) const

int16_column &	get_int16_column (size_t column_id)

const_int16_column &	get_int16_column (size_t column_id) const

int32_column &	get_int32_column (size_t column_id)

const_int32_column &	get_int32_column (size_t column_id) const

int64_column &	get_int64_column (size_t column_id)

const_int64_column &	get_int64_column (size_t column_id) const

int8_column &	get_int8_column (size_t column_id)

const_int8_column &	get_int8_column (size_t column_id) const

std::string	get_key (uint64_t key_id) const

std::string	get_key_nolock (uint64_t key_id) const

util::concurrent::rw_mutex &	get_mutex () const

void	get_row (const uint64_t id, framework::packer &pk) const

string_column &	get_string_column (size_t column_id)

const_string_column &	get_string_column (size_t column_id) const

uint16_column &	get_uint16_column (size_t column_id)

const_uint16_column &	get_uint16_column (size_t column_id) const

uint32_column &	get_uint32_column (size_t column_id)

const_uint32_column &	get_uint32_column (size_t column_id) const

uint64_column &	get_uint64_column (size_t column_id)

const_uint64_column &	get_uint64_column (size_t column_id) const

uint8_column &	get_uint8_column (size_t column_id)

const_uint8_column &	get_uint8_column (size_t column_id) const

version_t	get_version (uint64_t index) const

void	init (const std::vector< column_type > &schema)

	MSGPACK_DEFINE (keys_, tuples_, versions_, columns_, clock_, index_)

void	pack (framework::packer &packer) const

void	scan_clock ()

version_t	set_row (const msgpack::object &o)

uint64_t	size () const

void	unpack (msgpack::object o)

template<typename T >
bool	update (const std::string &key, const owner &o, size_t column_id, const T &v)

bool	update_clock (const std::string &target, const owner &o)

bool	update_clock (const uint64_t index, const owner &o)

	~column_table ()

Private Types
typedef jubatus::util::data::unordered_map< std::string, uint64_t >	index_table

Private Member Functions
void	delete_row_ (uint64_t index)

Private Attributes
uint64_t	clock_

std::vector< detail::abstract_column >	columns_

index_table	index_

std::vector< std::string >	keys_

jubatus::util::concurrent::rw_mutex	table_lock_

uint64_t	tuples_

std::vector< version_t >	versions_

Friends
std::ostream &	operator<< (std::ostream &os, const column_table &tbl)

Detailed Description

Definition at line 55 of file column_table.hpp.

Member Typedef Documentation

typedef jubatus::util::data::unordered_map<std::string, uint64_t> jubatus::core::storage::column_table::index_table

private

Definition at line 56 of file column_table.hpp.

typedef std::pair<owner, uint64_t> jubatus::core::storage::column_table::version_t

Definition at line 59 of file column_table.hpp.

Constructor & Destructor Documentation

jubatus::core::storage::column_table::column_table ( )

inline

Definition at line 61 of file column_table.hpp.

62 : tuples_(0), clock_(0) {

63 }

jubatus::core::storage::column_table::tuples_

uint64_t tuples_

Definition: column_table.hpp:383

jubatus::core::storage::column_table::clock_

uint64_t clock_

Definition: column_table.hpp:384

jubatus::core::storage::column_table::~column_table ( )

inline

Definition at line 64 of file column_table.hpp.

64 {

65 }

Member Function Documentation

template<typename T1 >

bool jubatus::core::storage::column_table::add	(	const std::string &	key,
		const owner &	o,
		const T1 &	v1
	)

inline

Definition at line 71 of file column_table.hpp.

References clock_, columns_, index_, JUBATUS_ASSERT_EQ, keys_, table_lock_, tuples_, and versions_.

                                                                {
     if (columns_.size() != 1) {
       throw length_unmatch_exception(
           "tuple's length unmatch, expected " +
           jubatus::util::lang::lexical_cast<std::string>(tuples_) + " tuples.");
     }
     // check already exists
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     index_table::const_iterator it = index_.find(key);
     const bool not_found = it == index_.end();
     if (not_found) {
       // add tuple
       keys_.push_back(key);
       versions_.push_back(std::make_pair(o, clock_));
       columns_[0].push_back(v1);
       JUBATUS_ASSERT_EQ(keys_.size(), versions_.size(), "");
 
       // make index
       index_.insert(std::make_pair(key, tuples_));
       ++tuples_;
     } else {  // key exists
       const uint64_t index = it->second;
       versions_[index] = std::make_pair(o, clock_);
       columns_[0].update(index, v1);
     }
     ++clock_;
     return not_found;
   }

template<typename T1 , typename T2 >

bool jubatus::core::storage::column_table::add	(	const std::string &	key,
		const owner &	o,
		const T1 &	v1,
		const T2 &	v2
	)

inline

Definition at line 101 of file column_table.hpp.

References clock_, columns_, index_, JUBATUS_ASSERT_EQ, keys_, table_lock_, tuples_, and versions_.

                                                                              {
     if (columns_.size() != 2) {
       throw length_unmatch_exception(
           "tuple's length unmatch, expected " +
           jubatus::util::lang::lexical_cast<std::string>(tuples_) + " tuples.");
     }
 
     // check already exists */
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     index_table::const_iterator it = index_.find(key);
     const bool not_found = it == index_.end();
     if (not_found) {
       // add tuple
       keys_.push_back(key);
       versions_.push_back(std::make_pair(o , clock_));
       columns_[0].push_back(v1);
       columns_[1].push_back(v2);
       JUBATUS_ASSERT_EQ(keys_.size(), versions_.size(), "");
 
       // make index
       index_.insert(std::make_pair(key, tuples_));
       ++tuples_;
     } else {  // key exists
       const uint64_t index = it->second;
       versions_[index] = std::make_pair(o, clock_);
       columns_[0].update(index, v1);
       columns_[1].update(index, v2);
     }
     ++clock_;
     return not_found;
   }

void jubatus::core::storage::column_table::clear ( )

Definition at line 47 of file column_table.cpp.

References clock_, columns_, index_, keys_, table_lock_, tuples_, and versions_.

                          {
   jutil::concurrent::scoped_wlock lk(table_lock_);
   // it keeps schema
   keys_.clear();
   versions_.clear();
   for (size_t i = 0; i < columns_.size(); ++i) {
     columns_[i].clear();
   }
   tuples_ = 0;
   clock_ = 0;
   index_.clear();
 }

bool jubatus::core::storage::column_table::delete_row ( const std::string & target )

inline

Definition at line 345 of file column_table.hpp.

References delete_row_(), index_, and table_lock_.

                                            {
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     index_table::const_iterator it = index_.find(target);
     if (it == index_.end()) {
       return false;
     }
     delete_row_(it->second);
     return true;
   }

Here is the call graph for this function:

bool jubatus::core::storage::column_table::delete_row ( uint64_t index )

inline

Definition at line 355 of file column_table.hpp.

References delete_row_(), size(), and table_lock_.

                                   {
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     if (size() <= index) {
       return false;
     }
     delete_row_(index);
     return true;
   }

Here is the call graph for this function:

void jubatus::core::storage::column_table::delete_row_ ( uint64_t index )

inlineprivate

Definition at line 387 of file column_table.hpp.

References clock_, JUBATUS_ASSERT_EQ, JUBATUS_ASSERT_LT, size(), jubatus::core::clustering::swap(), and tuples_.

Referenced by delete_row().

                                    {
     JUBATUS_ASSERT_LT(index, size(), "");
 
     for (std::vector<detail::abstract_column>::iterator jt = columns_.begin();
          jt != columns_.end();
          ++jt) {
       jt->remove(index);
     }
     {  // needs swap on last index
       index_table::iterator move_it = index_.find(keys_[tuples_ - 1]);
       move_it->second = index;
       index_.erase(keys_[index]);
     }
 
     if (index + 1 != keys_.size()) {
       std::swap(keys_[index], keys_.back());
     }
     keys_.pop_back();
 
     if (index + 1 != versions_.size()) {
       std::swap(versions_[index], versions_.back());
     }
     versions_.pop_back();
 
     --tuples_;
     ++clock_;
 
     JUBATUS_ASSERT_EQ(tuples_, index_.size(), "");
     JUBATUS_ASSERT_EQ(tuples_, keys_.size(), "");
     JUBATUS_ASSERT_EQ(tuples_, versions_.size(), "");
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string jubatus::core::storage::column_table::dump_json ( ) const

inline

Definition at line 210 of file column_table.hpp.

References table_lock_, and tuples_.

                               {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     std::stringstream ss;
     ss << tuples_;
     return ss.str();
   }

std::pair< bool, uint64_t > jubatus::core::storage::column_table::exact_match ( const std::string & prefix ) const

Definition at line 60 of file column_table.cpp.

References index_, and table_lock_.

                                    {
   jutil::concurrent::scoped_rlock lk(table_lock_);
   index_table::const_iterator it = index_.find(prefix);
   if (it == index_.end()) {
     return std::make_pair(false, 0LLU);
   } else {
     return std::make_pair(true, it->second);
   }
 }

bit_vector_column & jubatus::core::storage::column_table::get_bit_vector_column ( size_t column_id )

Definition at line 159 of file column_table.cpp.

References jubatus::core::storage::column_type::bit_vector_type, columns_, and JUBATUS_ASSERT.

                                                                        {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::bit_vector_type));
   return *static_cast<bit_vector_column*>(columns_[column_id].get());
 }

const_bit_vector_column & jubatus::core::storage::column_table::get_bit_vector_column ( size_t column_id ) const

Definition at line 163 of file column_table.cpp.

References jubatus::core::storage::column_type::bit_vector_type, columns_, and JUBATUS_ASSERT.

                             {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::bit_vector_type));
   return *static_cast<const_bit_vector_column*>(columns_[column_id].get());
 }

version_t jubatus::core::storage::column_table::get_clock ( const std::string & target ) const

inline

Definition at line 328 of file column_table.hpp.

References index_, table_lock_, and versions_.

                                                      {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     index_table::const_iterator it = index_.find(target);
     if (it == index_.end()) {
       return version_t();
     }
     return versions_[it->second];
   }

version_t jubatus::core::storage::column_table::get_clock ( const uint64_t index ) const

inline

Definition at line 337 of file column_table.hpp.

References size(), table_lock_, and versions_.

                                                   {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     if (size() < index) {
       return version_t();
     }
     return versions_[index];
   }

Here is the call graph for this function:

double_column & jubatus::core::storage::column_table::get_double_column ( size_t column_id )

Definition at line 143 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::double_type, and JUBATUS_ASSERT.

                                                                {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::double_type));
   return *static_cast<double_column*>(columns_[column_id].get());
 }

const_double_column & jubatus::core::storage::column_table::get_double_column ( size_t column_id ) const

Definition at line 147 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::double_type, and JUBATUS_ASSERT.

                                                                            {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::double_type));
   return *static_cast<const_double_column*>(columns_[column_id].get());
 }

float_column & jubatus::core::storage::column_table::get_float_column ( size_t column_id )

Definition at line 135 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::float_type, and JUBATUS_ASSERT.

                                                              {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::float_type));
   return *static_cast<float_column*>(columns_[column_id].get());
 }

const_float_column & jubatus::core::storage::column_table::get_float_column ( size_t column_id ) const

Definition at line 139 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::float_type, and JUBATUS_ASSERT.

                                                                          {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::float_type));
   return *static_cast<const_float_column*>(columns_[column_id].get());
 }

int16_column & jubatus::core::storage::column_table::get_int16_column ( size_t column_id )

Definition at line 111 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int16_type, and JUBATUS_ASSERT.

                                                              {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int16_type));
   return *static_cast<int16_column*>(columns_[column_id].get());
 }

const_int16_column & jubatus::core::storage::column_table::get_int16_column ( size_t column_id ) const

Definition at line 115 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int16_type, and JUBATUS_ASSERT.

                                                                          {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int16_type));
   return *static_cast<const_int16_column*>(columns_[column_id].get());
 }

int32_column & jubatus::core::storage::column_table::get_int32_column ( size_t column_id )

Definition at line 119 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int32_type, and JUBATUS_ASSERT.

                                                              {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int32_type));
   return *static_cast<int32_column*>(columns_[column_id].get());
 }

const_int32_column & jubatus::core::storage::column_table::get_int32_column ( size_t column_id ) const

Definition at line 123 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int32_type, and JUBATUS_ASSERT.

                                                                          {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int32_type));
   return *static_cast<const_int32_column*>(columns_[column_id].get());
 }

int64_column & jubatus::core::storage::column_table::get_int64_column ( size_t column_id )

Definition at line 127 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int64_type, and JUBATUS_ASSERT.

                                                              {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int64_type));
   return *static_cast<int64_column*>(columns_[column_id].get());
 }

const_int64_column & jubatus::core::storage::column_table::get_int64_column ( size_t column_id ) const

Definition at line 131 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int64_type, and JUBATUS_ASSERT.

                                                                          {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int64_type));
   return *static_cast<const_int64_column*>(columns_[column_id].get());
 }

int8_column & jubatus::core::storage::column_table::get_int8_column ( size_t column_id )

Definition at line 103 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int8_type, and JUBATUS_ASSERT.

                                                            {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int8_type));
   return *static_cast<int8_column*>(columns_[column_id].get());
 }

const_int8_column & jubatus::core::storage::column_table::get_int8_column ( size_t column_id ) const

Definition at line 107 of file column_table.cpp.

References columns_, jubatus::core::storage::column_type::int8_type, and JUBATUS_ASSERT.

                                                                        {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::int8_type));
   return *static_cast<const_int8_column*>(columns_[column_id].get());
 }

std::string jubatus::core::storage::column_table::get_key ( uint64_t key_id ) const

inline

Definition at line 152 of file column_table.hpp.

References get_key_nolock(), and table_lock_.

                                            {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     return get_key_nolock(key_id);
   }

Here is the call graph for this function:

std::string jubatus::core::storage::column_table::get_key_nolock ( uint64_t key_id ) const

inline

Definition at line 157 of file column_table.hpp.

References keys_, and tuples_.

Referenced by get_key().

                                                   {
     if (tuples_ <= key_id) {
       return "";
     }
     return keys_[key_id];
   }

Here is the caller graph for this function:

util::concurrent::rw_mutex& jubatus::core::storage::column_table::get_mutex ( ) const

inline

Definition at line 364 of file column_table.hpp.

References table_lock_.

                                             {
     return table_lock_;
   }

void jubatus::core::storage::column_table::get_row	(	const uint64_t	id,
		framework::packer &	pk
	)		const

inline

Definition at line 244 of file column_table.hpp.

References columns_, JUBATUS_ASSERT_GE, keys_, table_lock_, tuples_, and versions_.

                                                              {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     JUBATUS_ASSERT_GE(tuples_, id, "specified index is bigger than table size");
     pk.pack_array(3);  // [key, [owner, id], [data]]
     pk.pack(keys_[id]);  // key
     pk.pack(versions_[id]);  // [version]
     pk.pack_array(columns_.size());
     for (size_t i = 0; i < columns_.size(); ++i) {
       columns_[i].pack_with_index(id, pk);
     }
   }

string_column & jubatus::core::storage::column_table::get_string_column ( size_t column_id )

Definition at line 151 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::string_type.

                                                                {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::string_type));
   return *static_cast<string_column*>(columns_[column_id].get());
 }

const_string_column & jubatus::core::storage::column_table::get_string_column ( size_t column_id ) const

Definition at line 155 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::string_type.

                                                                            {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::string_type));
   return *static_cast<const_string_column*>(columns_[column_id].get());
 }

uint16_column & jubatus::core::storage::column_table::get_uint16_column ( size_t column_id )

Definition at line 79 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint16_type.

                                                                {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint16_type));
   return *static_cast<uint16_column*>(columns_[column_id].get());
 }

const_uint16_column & jubatus::core::storage::column_table::get_uint16_column ( size_t column_id ) const

Definition at line 83 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint16_type.

                                                                            {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint16_type));
   return *static_cast<const uint16_column*>(columns_[column_id].get());
 }

uint32_column & jubatus::core::storage::column_table::get_uint32_column ( size_t column_id )

Definition at line 87 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint32_type.

                                                                {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint32_type));
   return *static_cast<uint32_column*>(columns_[column_id].get());
 }

const_uint32_column & jubatus::core::storage::column_table::get_uint32_column ( size_t column_id ) const

Definition at line 91 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint32_type.

                                                                            {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint32_type));
   return *static_cast<const_uint32_column*>(columns_[column_id].get());
 }

uint64_column & jubatus::core::storage::column_table::get_uint64_column ( size_t column_id )

Definition at line 95 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint64_type.

                                                                {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint64_type));
   return *static_cast<uint64_column*>(columns_[column_id].get());
 }

const_uint64_column & jubatus::core::storage::column_table::get_uint64_column ( size_t column_id ) const

Definition at line 99 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint64_type.

                                                                            {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint64_type));
   return *static_cast<const_uint64_column*>(columns_[column_id].get());
 }

uint8_column & jubatus::core::storage::column_table::get_uint8_column ( size_t column_id )

Definition at line 71 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint8_type.

                                                              {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint8_type));
   return *static_cast<uint8_column*>(columns_[column_id].get());
 }

const_uint8_column & jubatus::core::storage::column_table::get_uint8_column ( size_t column_id ) const

Definition at line 75 of file column_table.cpp.

References columns_, JUBATUS_ASSERT, and jubatus::core::storage::column_type::uint8_type.

                                                                          {
   JUBATUS_ASSERT(columns_[column_id].type().is(column_type::uint8_type));
   return *static_cast<const uint8_column*>(columns_[column_id].get());
 }

version_t jubatus::core::storage::column_table::get_version ( uint64_t index ) const

inline

Definition at line 239 of file column_table.hpp.

References table_lock_, and versions_.

                                               {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     return versions_[index];
   }

void jubatus::core::storage::column_table::init ( const std::vector< column_type > & schema )

Definition at line 32 of file column_table.cpp.

References columns_, and table_lock_.

                                                             {
   jutil::concurrent::scoped_wlock lk(table_lock_);
   /* defining tuple */
   if (!columns_.empty()) {
     throw storage_exception(
         "Storage's schemas cannot be over written. Clear schemas before "
         "init()");
   }
   for (std::vector<column_type>::const_iterator it = schema.begin();
        it != schema.end();
        ++it) {
     columns_.push_back(detail::abstract_column(*it));
   }
 }

jubatus::core::storage::column_table::MSGPACK_DEFINE	(	keys_	,
		tuples_	,
		versions_	,
		columns_	,
		clock_	,
		index_
	)

void jubatus::core::storage::column_table::pack ( framework::packer & packer ) const

inline

Definition at line 370 of file column_table.hpp.

                                            {
     packer.pack(*this);
   }

void jubatus::core::storage::column_table::scan_clock ( )

inline

Definition at line 164 of file column_table.hpp.

References clock_, table_lock_, and versions_.

                     {
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     uint64_t max_clock = 0;
     for (std::vector<version_t>::const_iterator it = versions_.begin();
          it != versions_.end(); ++it) {
       max_clock = std::max(max_clock, it->second);
     }
     clock_ = max_clock;
   }

version_t jubatus::core::storage::column_table::set_row ( const msgpack::object & o )

inline

Definition at line 256 of file column_table.hpp.

References clock_, columns_, index_, JUBATUS_ASSERT_EQ, keys_, table_lock_, tuples_, and versions_.

                                             {
     if (o.type != msgpack::type::ARRAY || o.via.array.size != 3) {
       throw msgpack::type_error();
     }
 
     const std::string& key = o.via.array.ptr[0].as<std::string>();
     version_t set_version = o.via.array.ptr[1].as<version_t>();
 
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     const msgpack::object& dat = o.via.array.ptr[2];
     index_table::iterator it = index_.find(key);
     if (it == index_.end()) {  // did not exist, append
       if (dat.via.array.size != columns_.size()) {
         throw std::bad_cast();
       }
 
       // add tuple
       keys_.push_back(key);
       versions_.push_back(set_version);
       for (size_t i = 0; i < columns_.size(); ++i) {
         columns_[i].push_back(dat.via.array.ptr[i]);
       }
       JUBATUS_ASSERT_EQ(keys_.size(), versions_.size(), "");
 
       // make index
       index_.insert(std::make_pair(key, tuples_));
       ++tuples_;
     } else {  // already exist, overwrite if needed
       const uint64_t target = it->second;
 
       if (dat.via.array.size != columns_.size()) {
         throw std::bad_cast();
       }
 
       // overwrite tuple if needed
       if (versions_[target].second <= set_version.second) {
         // needed!!
         versions_[target] = set_version;
         for (size_t i = 0; i < columns_.size(); ++i) {
           columns_[i].update(target, dat.via.array.ptr[i]);
         }
         // make index
         index_.insert(std::make_pair(key, tuples_));
       }
     }
     if (clock_ <= set_version.second) {
       clock_ = set_version.second + 1;
     }
     return set_version;
   }

uint64_t jubatus::core::storage::column_table::size ( ) const

inline

Definition at line 205 of file column_table.hpp.

References table_lock_, and tuples_.

Referenced by delete_row(), delete_row_(), get_clock(), and update_clock().

                         {
     jubatus::util::concurrent::scoped_rlock lk(table_lock_);
     return tuples_;
   }

Here is the caller graph for this function:

void jubatus::core::storage::column_table::unpack ( msgpack::object o )

inline

Definition at line 374 of file column_table.hpp.

                                {
     o.convert(this);
   }

template<typename T >

bool jubatus::core::storage::column_table::update	(	const std::string &	key,
		const owner &	o,
		size_t	column_id,
		const T &	v
	)

inline

Definition at line 135 of file column_table.hpp.

References clock_, columns_, index_, table_lock_, tuples_, and versions_.

                   {
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     index_table::iterator it = index_.find(key);
     if (tuples_ < column_id || it == index_.end()) {
       return false;
     }
     versions_[it->second] = std::make_pair(o, clock_);
     columns_[column_id].update(it->second, v);
     columns_[column_id].update(it->second, v);
     ++clock_;
     return true;
   }

bool jubatus::core::storage::column_table::update_clock	(	const std::string &	target,
		const owner &	o
	)

inline

Definition at line 307 of file column_table.hpp.

References clock_, index_, table_lock_, and versions_.

                                                              {
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     index_table::const_iterator it = index_.find(target);
     if (it == index_.end()) {
       return false;
     }
     versions_[it->second] = std::make_pair(o, clock_);
     ++clock_;
     return true;
   }

bool jubatus::core::storage::column_table::update_clock	(	const uint64_t	index,
		const owner &	o
	)

inline

Definition at line 318 of file column_table.hpp.

References clock_, size(), table_lock_, and versions_.

                                                           {
     jubatus::util::concurrent::scoped_wlock lk(table_lock_);
     if (size() < index) {
       return false;
     }
     versions_[index] = std::make_pair(o, clock_);
     ++clock_;
     return true;
   }

Here is the call graph for this function:

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const column_table &	tbl
	)

friend

Definition at line 219 of file column_table.hpp.

                                                                          {
     jubatus::util::concurrent::scoped_rlock lk(tbl.table_lock_);
     os << "total size:" << tbl.tuples_ << std::endl;
     os << "types: vesions|";
     for (size_t j = 0; j < tbl.columns_.size(); ++j) {
       os << tbl.columns_[j].type().type_as_string() << "\t|";
     }
     os << std::endl;
     for (uint64_t i = 0; i < tbl.tuples_; ++i) {
       os << tbl.keys_[i] << ":" <<
           tbl.versions_[i].first << ":" << tbl.versions_[i].second << "\t|";
       for (size_t j = 0; j < tbl.columns_.size(); ++j) {
         tbl.columns_[j].dump(os, i);
         os << "\t|";
       }
       os << std::endl;
     }
     return os;
   }