Small additions so that createKeyspace works correctly. createColumnF…

…amily still not working as expected.

libcassandra/column_family_definition.cc

@@ -23,10 +23,10 @@ ColumnFamilyDefinition::ColumnFamilyDefinition()
   :
     keyspace_name(),
     name(),
-    column_type(),
-    comparator_type(),
+    column_type("Standard"),
+    comparator_type("BytesType"),
     sub_comparator_type(),
-    comment(),
+    comment("what"),
     row_cache_size(0.0),
     key_cache_size(0.0),
     read_repair_chance(0.0),
@@ -411,3 +411,21 @@ bool ColumnFamilyDefinition::isMemtableThroughputInMbSet() const
   return (memtable_throughput_in_mb > 0 ? true : false);
 }
 
+
+vector<ColumnDefinition> ColumnFamilyDefinition::getColumnMetadata() const
+{
+  return column_metadata;
+}
+
+
+void ColumnFamilyDefinition::setColumnMetadata(vector<ColumnDefinition>& meta)
+{
+  column_metadata.clear();
+  for (vector<ColumnDefinition>::iterator it= meta.begin();
+       it != meta.end();
+       ++it)
+  {
+    column_metadata.push_back(*it);
+  }
+}
+

libcassandra/column_family_definition.h

@@ -257,6 +257,10 @@ class ColumnFamilyDefinition
    */
   bool isMemtableThroughputInMbSet() const;
 
+  std::vector<ColumnDefinition> getColumnMetadata() const;
+
+  void setColumnMetadata(std::vector<ColumnDefinition>& meta);
+
 private:
 
   std::string keyspace_name;

libcassandra/keyspace_definition.cc

@@ -22,9 +22,9 @@ using namespace org::apache::cassandra;
 KeyspaceDefinition::KeyspaceDefinition()
   :
     name(),
-    strategy_class(),
+    strategy_class("org.apache.cassandra.locator.NetworkTopologyStrategy"),
     strategy_options(),
-    replication_factor(),
+    replication_factor(1),
     col_family_defs()
 {}
 
@@ -77,19 +77,62 @@ string KeyspaceDefinition::getName() const
 }
 
 
+void KeyspaceDefinition::setName(const string& ks_name)
+{
+  name.assign(ks_name);
+}
+
+
 string KeyspaceDefinition::getStrategyClass() const
 {
   return strategy_class;
 }
 
 
+void KeyspaceDefinition::setStrategyClass(const string& strat_class)
+{
+  strategy_class.assign(strat_class);
+}
+
+
 map<string, string> KeyspaceDefinition::getStrategyOptions() const
 {
   return strategy_options;
 }
 
 
+void KeyspaceDefinition::setStrategyOptions(const map<string, string>& opts)
+{
+  (void) opts;
+}
+
+
 int32_t KeyspaceDefinition::getReplicationFactor() const
 {
   return replication_factor;
 }
+
+
+void KeyspaceDefinition::setReplicationFactor(int32_t rep_factor)
+{
+  replication_factor= rep_factor;
+}
+
+
+vector<ColumnFamilyDefinition> KeyspaceDefinition::getColumnFamilies() const
+{
+  return col_family_defs;
+}
+
+
+void KeyspaceDefinition::setColumnFamilies(vector<ColumnFamilyDefinition>& cfs)
+{
+  col_family_defs.clear();
+  for (vector<ColumnFamilyDefinition>::iterator it= cfs.begin();
+       it != cfs.end();
+       ++it)
+  {
+    col_family_defs.push_back(*it);
+  }
+}
+

libcassandra/keyspace_definition.h

@@ -41,21 +41,36 @@ class KeyspaceDefinition
    */
   std::string getName() const;
 
+  void setName(const std::string& ks_name);
+
   /**
    * @return strategy class name for this keyspace
    */
   std::string getStrategyClass() const;
 
+  void setStrategyClass(const std::string& strat_class);
+
   /**
    * @return strategy options for this keyspace
    */
   std::map<std::string, std::string> getStrategyOptions() const;
 
+  void setStrategyOptions(const std::map<std::string, std::string>& opts);
+
   /**
    * @return replication factor for this keyspace
    */
   int32_t getReplicationFactor() const;
 
+  void setReplicationFactor(int32_t rep_factor);
+
+  /**
+   * @return the column families in this keyspace
+   */
+  std::vector<ColumnFamilyDefinition> getColumnFamilies() const;
+
+  void setColumnFamilies(std::vector<ColumnFamilyDefinition>& cfs);
+
 private:
 
   std::string name;

libcassandra/util_functions.cc

@@ -49,6 +49,15 @@ KsDef createKsDefObject(const KeyspaceDefinition& ks_def)
   KsDef thrift_ks_def;
   thrift_ks_def.name.assign(ks_def.getName());
   thrift_ks_def.strategy_class.assign(ks_def.getStrategyClass());
+  vector<ColumnFamilyDefinition> cf_defs= ks_def.getColumnFamilies();
+  for (vector<ColumnFamilyDefinition>::iterator it= cf_defs.begin();
+       it != cf_defs.end();
+       ++it)
+  {
+    CfDef entry= createCfDefObject(*it);
+    thrift_ks_def.cf_defs.push_back(entry);
+  }
+  thrift_ks_def.replication_factor= ks_def.getReplicationFactor();
   return thrift_ks_def;
 }
 

tests/cassandra_client_test.cc

@@ -21,6 +21,7 @@
 #include <libgenthrift/Cassandra.h>
 #include <libcassandra/cassandra.h>
 #include <libcassandra/cassandra_factory.h>
+#include <libcassandra/column_family_definition.h>
 #include <libcassandra/keyspace.h>
 #include <libcassandra/keyspace_definition.h>
 
@@ -137,8 +138,18 @@ TEST(Cassandra, GetSpecificKeyspace)
 TEST_F(ClientTest, InsertColumn)
 {
   const string mock_data("this is mock data being inserted...");
-  c->insertColumn("sarah", "Standard1", "third", mock_data);
-  string res= c->getColumnValue("sarah", "Standard1", "third");
+  KeyspaceDefinition ks_def;
+  ks_def.setName("unittest");
+  ks_def.setReplicationFactor(1);
+  //c->createKeyspace(ks_def);
+  ColumnFamilyDefinition cf_def;
+  cf_def.setName("padraig");
+  cf_def.setKeyspaceName(ks_def.getName());
+  cout << "creating column family..." << endl;
+  c->createColumnFamily(cf_def);
+  cout << "getting to insert data ..." << endl;
+  c->insertColumn("sarah", "padraig", "third", mock_data);
+  string res= c->getColumnValue("sarah", "padraig", "third");
   EXPECT_EQ(mock_data, res);
   EXPECT_STREQ(mock_data.c_str(), res.c_str());
 }