Storage modules

.travis.yml

@@ -12,11 +12,6 @@ env:
   matrix:
     - TEST_CASSANDRA_VERSION=3.11.4
 
-stages:
-  - test
-  - build_wheel_manylinux2010
-  - build_wheel_manylinux1
-
 before_install:
   - source .travis/install_openjdk8.sh
 
@@ -40,27 +35,7 @@ addons:
 
 # command to run tests
 script:
-  - nosetests --with-coverage -v -s hecuba_py/tests/*.py
-  - nosetests --with-coverage -v -s hecuba_py/tests/withcassandra
-
-jobs:
-  include:
-    - stage: build_wheel_manylinux2010
-      sudo: required
-      env:
-        - DOCKER_IMAGE=quay.io/pypa/manylinux2010_x86_64  PLAT=manylinux2010_x86_64
-      install:
-        - docker pull $DOCKER_IMAGE
-      script:
-        - docker run --rm -e PLAT=$PLAT -v `pwd`:/io $DOCKER_IMAGE /io/.travis/build-wheels.sh
-    - stage: build_wheel_manylinux1
-      sudo: required
-      env:
-        - DOCKER_IMAGE=quay.io/pypa/manylinux1_x86_64  PLAT=manylinux1_x86_64
-      install:
-        - docker pull $DOCKER_IMAGE
-      script:
-        - docker run --rm -e PLAT=$PLAT -v `pwd`:/io $DOCKER_IMAGE /io/.travis/build-wheels.sh
+  - nosetests --with-coverage -v -s storage/cql_iface/tests/api_tests.py
 
 # Push the results back to codecov
 after_success:

hecuba_core/CMakeLists.txt

@@ -210,8 +210,8 @@ if (NOT TBB_FOUND)
     ExternalProject_Add(
             TBB
             DOWNLOAD_DIR ${CMAKE_CURRENT_LIST_DIR}/dependencies
-            URL "https://www.threadingbuildingblocks.org/sites/default/files/software_releases/source/tbb2017_20161128oss_src.tgz"
-            URL_HASH SHA1=2c451a5bcf6fc31487b98b4b29651c369874277c
+            URL "https://github.com/intel/tbb/archive/v2020.0.tar.gz"
+            URL_HASH SHA1=0b8e9db0c7672eea6207e6749e14ec80b1b4eaa7
             CMAKE_COMMAND echo
             BUILD_COMMAND make tbb tbb_build_prefix=${build_prefix}
             BUILD_IN_SOURCE 1

hecuba_core/src/TableMetadata.cpp

@@ -40,9 +40,7 @@ uint16_t TableMetadata::compute_size_of(const ColumnMeta &CM) const {
             return sizeof(int32_t);
         }
         case CASS_VALUE_TYPE_TIMESTAMP: {
-            //TODO
-            std::cerr << "Timestamp data type supported yet" << std::endl;
-            break;
+            return sizeof(int64_t);
         }
         case CASS_VALUE_TYPE_UUID: {
             return sizeof(uint64_t *);
@@ -58,16 +56,10 @@ uint16_t TableMetadata::compute_size_of(const ColumnMeta &CM) const {
             break;
         }
         case CASS_VALUE_TYPE_DATE: {
-            std::cerr << "Date data type supported yet" << std::endl;
-
-            //TODO
-            break;
+            return sizeof(int64_t);
         }
         case CASS_VALUE_TYPE_TIME: {
-            std::cerr << "Time data type supported yet" << std::endl;
-            //TODO
-
-            break;
+            return sizeof(int64_t);
         }
         case CASS_VALUE_TYPE_SMALL_INT: {
             return sizeof(int16_t);

hecuba_core/src/TupleRow.h

@@ -8,7 +8,7 @@
 #include <stdlib.h>
 #include <vector>
 #include <cassandra.h>
-
+#include <set>
 
 #include "TableMetadata.h"
 
@@ -35,6 +35,10 @@ class TupleRow {
 
 
     /* Set methods */
+    inline void set_keys(std::set<std::string> keys) {
+        this->payload->set_keys(keys);
+    }
+
     inline void setNull(uint32_t position) {
         this->payload->setNull(position);
     }
@@ -47,8 +51,11 @@ class TupleRow {
         this->payload->setTimestamp(timestamp);
     }
 
-
     /* Get methods */
+    inline const std::set<std::string> get_keys() const {
+        return this->payload->get_keys();
+    }
+
     inline bool isNull(uint32_t position) const {
         return this->payload->isNull(position);
     }
@@ -100,6 +107,7 @@ class TupleRow {
         size_t ptr_length;
         std::vector<uint32_t> null_values;
         int64_t timestamp;
+        std::set<std::string> keys;
 
 
         /* Constructors */
@@ -122,6 +130,11 @@ class TupleRow {
          * we need to access the position must be divided by 32. This is accomplished by
          * doing bit shifting (5 positions to the right since 2^5=32).
          */
+
+        void set_keys(std::set<std::string> keys) {
+            this->keys = keys;
+        }
+
         void setNull(uint32_t position) {
             if (!null_values.empty()) this->null_values[position >> 5] |= (0x1 << (position % 32));
         }
@@ -144,6 +157,9 @@ class TupleRow {
             return this->timestamp;
         }
 
+        std::set<std::string> get_keys() const {
+            return this->keys;
+        }
 
         /* Comparators */
         bool operator<(TupleRowData &rhs) {

hecuba_core/src/TupleRowFactory.cpp

@@ -206,12 +206,32 @@ int TupleRowFactory::cass_to_c(const CassValue *lhs, void *data, int16_t col) co
             cass_iterator_free(tuple_iterator);
             return 0;
         }
+        case CASS_VALUE_TYPE_DATE: {
+            cass_uint32_t year_month_day;
+            CassError rc = cass_value_get_uint32(lhs, &year_month_day);
+            CHECK_CASS("TupleRowFactory: Cassandra to C parse uint32 unsuccessful, column:" + std::to_string(col));
+            if (rc == CASS_ERROR_LIB_NULL_VALUE) return -1;
+            int64_t time = (int64_t) cass_date_time_to_epoch(year_month_day, 0);
+            memcpy(data, &time, sizeof(int64_t *));
+            return 0;
+        }
+        case CASS_VALUE_TYPE_TIME: {
+            CassError rc = cass_value_get_int64(lhs, reinterpret_cast<int64_t * >(data));
+            CHECK_CASS("TupleRowFactory: Cassandra to C parse int64 unsuccessful, column:" + std::to_string(col));
+            if (rc == CASS_ERROR_LIB_NULL_VALUE) return -1;
+            return 0;
+        }
+        case CASS_VALUE_TYPE_TIMESTAMP: {
+            cass_int64_t time_of_day;
+            CassError rc = cass_value_get_int64(lhs, &time_of_day);
+            CHECK_CASS("TupleRowFactory: Cassandra to C parse int64 unsuccessful, column:" + std::to_string(col));
+            if (rc == CASS_ERROR_LIB_NULL_VALUE) return -1;
+            memcpy(data, &time_of_day, sizeof(int64_t *));
+            return 0;
+        }
         case CASS_VALUE_TYPE_DECIMAL:
-        case CASS_VALUE_TYPE_TIMESTAMP:
         case CASS_VALUE_TYPE_TIMEUUID:
         case CASS_VALUE_TYPE_INET:
-        case CASS_VALUE_TYPE_DATE:
-        case CASS_VALUE_TYPE_TIME:
         case CASS_VALUE_TYPE_LIST:
         case CASS_VALUE_TYPE_MAP:
         case CASS_VALUE_TYPE_SET:
@@ -326,12 +346,29 @@ TupleRowFactory::bind(CassTuple *tuple, const TupleRow *row) const {
                     CHECK_CASS("TupleRowFactory: Cassandra unsuccessful binding a new Tuple to the existing tuple");
                     break;
                 }
+                case CASS_VALUE_TYPE_DATE: {
+                    const time_t time = *((time_t *) element_i);
+                    uint32_t year_month_day = cass_date_from_epoch(time);
+                    CassError rc = cass_tuple_set_uint32(tuple, (size_t) bind_pos, year_month_day);
+                    CHECK_CASS("TupleRowFactory: Cassandra unsuccessful binding int64 to the tuple");
+                    break;
+                }
+                case CASS_VALUE_TYPE_TIME: {
+                    int64_t time = *((int64_t *) element_i);
+                    CassError rc = cass_tuple_set_int64(tuple, (size_t) bind_pos, time);
+                    CHECK_CASS("TupleRowFactory: Cassandra unsuccessful binding int64 to the tuple");
+                    break;
+                }
+                case CASS_VALUE_TYPE_TIMESTAMP: {
+                    cass_int64_t time = *((int64_t *) element_i);
+                    CassError rc = cass_tuple_set_int64(tuple, (size_t) bind_pos, time);
+                    CHECK_CASS("TupleRowFactory: Cassandra unsuccessful binding int64 to the tuple");
+                    break;
+
+                }
                 case CASS_VALUE_TYPE_DECIMAL:
-                case CASS_VALUE_TYPE_TIMESTAMP:
                 case CASS_VALUE_TYPE_TIMEUUID:
                 case CASS_VALUE_TYPE_INET:
-                case CASS_VALUE_TYPE_DATE:
-                case CASS_VALUE_TYPE_TIME:
                 case CASS_VALUE_TYPE_LIST:
                 case CASS_VALUE_TYPE_MAP:
                 case CASS_VALUE_TYPE_SET:
@@ -353,18 +390,17 @@ TupleRowFactory::bind(CassTuple *tuple, const TupleRow *row) const {
 void
 TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t offset) const {
 
-
     if (!row || !statement)
         throw ModuleException("Statement bind: Null tuple row or statement received");
-
     if (metadata->size() != row->n_elem())
         throw ModuleException("Statement bind: Found " + std::to_string(row->n_elem()) + ", expected " +
                               std::to_string(metadata->size()));
-
+    std::set<std::string> keys = row->get_keys();
     for (uint16_t i = 0; i < row->n_elem(); ++i) {
         uint16_t bind_pos = offset + i;
         const void *element_i = row->get_element(i);
-        if (element_i != nullptr && !row->isNull(i)) {
+        if (element_i != nullptr && !row->isNull(i)) { //if the element is null, the bind will use the default behaviour (if the table have data,
+                                                       //the bind will not touch it, if the table does not have data will insert null)
             switch (metadata->at(i).type) {
                 case CASS_VALUE_TYPE_VARCHAR:
                 case CASS_VALUE_TYPE_TEXT:
@@ -373,7 +409,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
                     const char *d = reinterpret_cast<char *>(*addr);
                     CassError rc = cass_statement_bind_string(statement, bind_pos, d);
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [text], column:" +
-                                       metadata->at(i).info.begin()->second);
+                               metadata->at(i).info.begin()->second);
                     break;
                 }
                 case CASS_VALUE_TYPE_VARINT:
@@ -382,7 +418,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
                     CassError rc = cass_statement_bind_int64(statement, bind_pos,
                                                              *data);//L means long long, K unsigned long long
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [bigint/varint], column:" +
-                                       metadata->at(i).info.begin()->second);
+                               metadata->at(i).info.begin()->second);
                     break;
                 }
                 case CASS_VALUE_TYPE_BLOB: {
@@ -417,7 +453,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
                     const double *data = static_cast<const double *>(element_i);
                     CassError rc = cass_statement_bind_double(statement, bind_pos, *data);
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [double], column:" +
-                                       metadata->at(i).info.begin()->second);
+                               metadata->at(i).info.begin()->second);
 
                     break;
                 }
@@ -426,7 +462,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
 
                     CassError rc = cass_statement_bind_float(statement, bind_pos, *data);
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [float], column:" +
-                                       metadata->at(i).info.begin()->second);
+                               metadata->at(i).info.begin()->second);
 
                     break;
                 }
@@ -435,7 +471,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
 
                     CassError rc = cass_statement_bind_int32(statement, bind_pos, *data);
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [int32], column:" +
-                                       metadata->at(i).info.begin()->second);
+                               metadata->at(i).info.begin()->second);
 
                     break;
                 }
@@ -449,7 +485,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
 
                     CassError rc = cass_statement_bind_uuid(statement, bind_pos, cass_uuid);
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [UUID], column:" +
-                                       metadata->at(i).info.begin()->second);
+                               metadata->at(i).info.begin()->second);
 
                     break;
                 }
@@ -466,8 +502,7 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
                     const int8_t *data = static_cast<const int8_t *>(element_i);
                     CassError rc = cass_statement_bind_int8(statement, bind_pos, *data);
                     CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [tiny int as int8], column:" +
-                                       metadata->at(i).info.begin()->second);
-
+                               metadata->at(i).info.begin()->second);
                     break;
                 }
                 case CASS_VALUE_TYPE_TUPLE: {
@@ -481,12 +516,31 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
                     cass_tuple_free(tuple);
                     break;
                 }
+                case CASS_VALUE_TYPE_DATE: {
+                    const time_t time = *((time_t *) element_i);
+                    cass_uint32_t year_month_day = cass_date_from_epoch(time);
+                    CassError rc = cass_statement_bind_uint32(statement, bind_pos, year_month_day);
+                    CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [date as int64], column:" +
+                               metadata->at(i).info.begin()->second);
+                    break;
+                }
+                case CASS_VALUE_TYPE_TIME: {
+                    int64_t time = *((int64_t *) element_i);
+                    CassError rc = cass_statement_bind_int64(statement, bind_pos, time);
+                    CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [time as int64], column:" +
+                               metadata->at(i).info.begin()->second);
+                    break;
+                }
+                case CASS_VALUE_TYPE_TIMESTAMP: {
+                    cass_int64_t time = *((int64_t *) element_i);
+                    CassError rc = cass_statement_bind_int64(statement, bind_pos, time);
+                    CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [timestamp as int64], column:" +
+                               metadata->at(i).info.begin()->second);
+                    break;
+                }
                 case CASS_VALUE_TYPE_DECIMAL:
-                case CASS_VALUE_TYPE_TIMESTAMP:
                 case CASS_VALUE_TYPE_TIMEUUID:
                 case CASS_VALUE_TYPE_INET:
-                case CASS_VALUE_TYPE_DATE:
-                case CASS_VALUE_TYPE_TIME:
                 case CASS_VALUE_TYPE_LIST:
                 case CASS_VALUE_TYPE_MAP:
                 case CASS_VALUE_TYPE_SET:
@@ -497,10 +551,12 @@ TupleRowFactory::bind(CassStatement *statement, const TupleRow *row, u_int16_t o
                     throw ModuleException("Default behaviour not supported");
             }
         } else {
-            //Element is a nullptr
-            CassError rc = cass_statement_bind_null(statement, bind_pos);
-            CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [Null value], column:" +
-                               metadata->at(i).info.begin()->second);
+            if (keys.find(metadata->at(i).info.find("name")->second) != keys.end()) {
+                //Element is a nullptr
+                CassError rc = cass_statement_bind_null(statement, bind_pos);
+                CHECK_CASS("TupleRowFactory: Cassandra binding query unsuccessful [Null value], column:" +
+                           metadata->at(i).info.begin()->second);
+            }
         }
     }
 }