PHP-170 - Duration nanos should support a signed 64-bit range

Author: mpenick

Diff for: behat.yml

@@ -7,7 +7,7 @@ default:
               tags: "[email protected]&&[email protected]&&~@broken"
             contexts:
                 - FeatureContext:
-                    cassandra_version: 3.0.8
+                    cassandra_version: "3.10"
 
 cassandra-version-2.2:
     formatters:

Diff for: ext/config.m4

@@ -270,8 +270,8 @@ if test "$PHP_CASSANDRA" != "no"; then
   AC_MSG_CHECKING([for supported DataStax C/C++ driver version])
   PHP_CASSANDRA_FOUND_CASSANDRA_VERSION=`$AWK '/CASS_VERSION_MAJOR/ {printf $3"."} /CASS_VERSION_MINOR/ {printf $3"."} /CASS_VERSION_PATCH/ {printf $3}' $CPP_DRIVER_DIR/include/cassandra.h`
   PHP_CASSANDRA_FOUND_CASSANDRA_VERSION_NUMBER=`echo "${PHP_CASSANDRA_FOUND_CASSANDRA_VERSION}" | $AWK 'BEGIN { FS = "."; } { printf "%d", ([$]1 * 100 + [$]2) * 100 + [$]3;}'`
-  if test "$PHP_CASSANDRA_FOUND_CASSANDRA_VERSION_NUMBER" -lt "20600"; then
-  AC_MSG_ERROR([not supported. Driver version 2.6.0+ required (found $PHP_CASSANDRA_FOUND_CASSANDRA_VERSION)])
+  if test "$PHP_CASSANDRA_FOUND_CASSANDRA_VERSION_NUMBER" -lt "20700"; then
+  AC_MSG_ERROR([not supported. Driver version 2.7.0+ required (found $PHP_CASSANDRA_FOUND_CASSANDRA_VERSION)])
   else
     AC_MSG_RESULT([supported ($PHP_CASSANDRA_FOUND_CASSANDRA_VERSION)])
   fi

Diff for: ext/config.w32

@@ -4,7 +4,7 @@ ARG_ENABLE("cassandra", "Enable DataStax PHP Cassandra extension", "no");
 
 // Establish the minimum Cassandra C/C++ driver and PHP version
 var driver_minimum_major = 2;
-var driver_minimum_minor = 6;
+var driver_minimum_minor = 7;
 var driver_minimum_patch = 0;
 var driver_minimum_version = driver_minimum_major + "." + driver_minimum_minor + "." + driver_minimum_patch;
 var php_minimum_major = 5;

Diff for: ext/php_driver_types.h

@@ -176,7 +176,7 @@ PHP_DRIVER_END_OBJECT_TYPE(inet)
 PHP_DRIVER_BEGIN_OBJECT_TYPE(duration)
   cass_int32_t months;
   cass_int32_t days;
-  cass_int32_t nanos;
+  cass_int64_t nanos;
 PHP_DRIVER_END_OBJECT_TYPE(duration)
 
 PHP_DRIVER_BEGIN_OBJECT_TYPE(collection)

Diff for: ext/src/Duration.c

@@ -15,64 +15,67 @@
 
 zend_class_entry *php_driver_duration_ce = NULL;
 
-static void to_string(zval *result, cass_int32_t value)
+static void to_string(zval *result, cass_int64_t value)
 {
   char *string;
-  spprintf(&string, 0, "%d", value);
+  spprintf(&string, 0, LL_FORMAT, value);
   PHP5TO7_ZVAL_STRING(result, string);
   efree(string);
 }
 
-static int get_int32(zval* value, cass_int32_t* destination, const char* param_name TSRMLS_DC)
+static int get_param(zval* value,
+                     const char* param_name,
+                     cass_int64_t min,
+                     cass_int64_t max,
+                     cass_int64_t *destination  TSRMLS_DC)
 {
-  // Adapted from Bigint __construct method.
   if (Z_TYPE_P(value) == IS_LONG) {
-    cass_int64_t long_value = Z_LVAL_P(value);
+    php5to7_long long_value = Z_LVAL_P(value);
 
-    if (long_value > INT32_MAX || long_value < INT32_MIN) {
-      zend_throw_exception_ex(php_driver_range_exception_ce, 0 TSRMLS_CC,
-        "%s must be between %d and %d, " LL_FORMAT " given",
-        param_name, INT32_MIN, INT32_MAX, long_value);
+    if (long_value > max || long_value < min) {
+      zend_throw_exception_ex(php_driver_invalid_argument_exception_ce, 0 TSRMLS_CC,
+        "%s must be between " LL_FORMAT " and " LL_FORMAT ", " LL_FORMAT " given",
+        param_name, min, max, long_value);
       return 0;
     }
 
     *destination = long_value;
   } else if (Z_TYPE_P(value) == IS_DOUBLE) {
     double double_value = Z_DVAL_P(value);
 
-    if (double_value > INT32_MAX || double_value < INT32_MIN) {
-      zend_throw_exception_ex(php_driver_range_exception_ce, 0 TSRMLS_CC,
-        "%s must be between %d and %d, %g given",
-        param_name, INT32_MIN, INT32_MAX, double_value);
+    if (double_value > max || double_value < min) {
+      zend_throw_exception_ex(php_driver_invalid_argument_exception_ce, 0 TSRMLS_CC,
+        "%s must be between " LL_FORMAT " and " LL_FORMAT ", %g given",
+        param_name, min, max, double_value);
       return 0;
     }
-    *destination = (cass_int32_t) double_value;
+    *destination = (cass_int64_t) double_value;
   } else if (Z_TYPE_P(value) == IS_STRING) {
     cass_int64_t parsed_big_int;
     if (!php_driver_parse_bigint(Z_STRVAL_P(value), Z_STRLEN_P(value), &parsed_big_int TSRMLS_CC)) {
       return 0;
     }
 
-    if (parsed_big_int > INT32_MAX || parsed_big_int < INT32_MIN) {
-      zend_throw_exception_ex(php_driver_range_exception_ce, 0 TSRMLS_CC,
-        "%s must be between %d and %d, " LL_FORMAT " given",
-        param_name, INT32_MIN, INT32_MAX, parsed_big_int);
+    if (parsed_big_int > max || parsed_big_int < min) {
+      zend_throw_exception_ex(php_driver_invalid_argument_exception_ce, 0 TSRMLS_CC,
+        "%s must be between " LL_FORMAT " and " LL_FORMAT ", " LL_FORMAT " given",
+        param_name, min, max, parsed_big_int);
       return 0;
     }
-    *destination = (cass_int32_t) parsed_big_int;
+    *destination = parsed_big_int;
   } else if (Z_TYPE_P(value) == IS_OBJECT &&
              instanceof_function(Z_OBJCE_P(value), php_driver_bigint_ce TSRMLS_CC)) {
     php_driver_numeric *bigint = PHP_DRIVER_GET_NUMERIC(value);
     cass_int64_t bigint_value = bigint->data.bigint.value;
 
-    if (bigint_value > INT32_MAX || bigint_value < INT32_MIN) {
-      zend_throw_exception_ex(php_driver_range_exception_ce, 0 TSRMLS_CC,
-        "%s must be between %d and %d, " LL_FORMAT " given",
-        param_name, INT32_MIN, INT32_MAX, bigint_value);
+    if (bigint_value > max || bigint_value < min) {
+      zend_throw_exception_ex(php_driver_invalid_argument_exception_ce, 0 TSRMLS_CC,
+        "%s must be between " LL_FORMAT " and " LL_FORMAT ", " LL_FORMAT " given",
+        param_name, min, max, bigint_value);
       return 0;
     }
 
-    *destination = (cass_int32_t) bigint_value;
+    *destination = bigint_value;
   } else {
     throw_invalid_argument(value, param_name, "a long, a double, a numeric string or a " \
                             PHP_DRIVER_NAMESPACE "\\Bigint" TSRMLS_CC);
@@ -91,7 +94,7 @@ char *php_driver_duration_to_string(php_driver_duration *duration)
   int is_negative = 0;
   cass_int32_t final_months = duration->months;
   cass_int32_t final_days = duration->days;
-  cass_int32_t final_nanos = duration->nanos;
+  cass_int64_t final_nanos = duration->nanos;
 
   is_negative = final_months < 0 || final_days < 0 || final_nanos < 0;
   if (final_months < 0)
@@ -101,14 +104,15 @@ char *php_driver_duration_to_string(php_driver_duration *duration)
   if (final_nanos < 0)
     final_nanos = -final_nanos;
 
-  spprintf(&rep, 0, "%s%dmo%dd%dns", is_negative ? "-" : "", final_months, final_days, final_nanos);
+  spprintf(&rep, 0, "%s%dmo%dd" LL_FORMAT "ns", is_negative ? "-" : "", final_months, final_days, final_nanos);
   return rep;
 }
 
 void
 php_driver_duration_init(INTERNAL_FUNCTION_PARAMETERS)
 {
   zval *months, *days, *nanos;
+  cass_int64_t param;
   php_driver_duration *self = NULL;
 
   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &months, &days, &nanos) == FAILURE) {
@@ -117,20 +121,23 @@ php_driver_duration_init(INTERNAL_FUNCTION_PARAMETERS)
 
   self = PHP_DRIVER_GET_DURATION(getThis());
 
-  if (!get_int32(months, &self->months, "months" TSRMLS_CC)) {
+  if (!get_param(months, "months", INT32_MIN, INT32_MAX, &param  TSRMLS_CC)) {
     return;
   }
-  if (!get_int32(days, &self->days, "days" TSRMLS_CC)) {
+  self->months = (cass_int32_t)param;
+
+  if (!get_param(days, "days", INT32_MIN, INT32_MAX, &param TSRMLS_CC)) {
     return;
   }
+  self->days = (cass_int32_t)param;
 
-  // No need to check the result of nanos parsing; get_int64 sets the exception if there's
-  // a failure, and we have no more work to do anyway.
-  get_int32(nanos, &self->nanos, "nanos" TSRMLS_CC);
+  if (!get_param(nanos, "nanos", INT64_MIN, INT64_MAX, &self->nanos TSRMLS_CC)) {
+    return;
+  }
 
   // Verify that all three attributes are non-negative or non-positive.
-  if (!(self->months <= 0 && self->days <= 0 && self->nanos <=0) &&
-      !(self->months >= 0 && self->days >= 0 && self->nanos >=0)) {
+  if (!(self->months <= 0 && self->days <= 0 && self->nanos <= 0) &&
+      !(self->months >= 0 && self->days >= 0 && self->nanos >= 0)) {
     zend_throw_exception_ex(spl_ce_BadFunctionCallException, 0 TSRMLS_CC, "%s",
       "A duration must have all non-negative or non-positive attributes"
     );

Diff for: features/duration.feature

@@ -0,0 +1,51 @@
+@cassandra-version-3.10
+Feature: Duration
+
+  PHP Driver supports the `Duration` datatype
+
+  Background:
+    Given a running Cassandra cluster
+
+  Scenario: Use the duration type
+    Given the following schema:
+      """cql
+      CREATE KEYSPACE simplex WITH replication = {
+        'class': 'SimpleStrategy',
+        'replication_factor': 1
+      };
+      USE simplex;
+      CREATE TABLE duration (k text PRIMARY KEY, d duration);
+      """
+    And the following example:
+      """
+      <?php
+      $cluster   = Cassandra::cluster()->build();
+      $session   = $cluster->connect("simplex");
+
+      $durations = array(
+          array('two_days', new Cassandra\Duration(2, 0, 0)),
+          array('twelve_hours', new Cassandra\Duration(0, 12, 0)),
+          array('three_seconds', new Cassandra\Duration(0, 0, 3 * (1000 ** 3))),
+          array('two_days_twelve_hours_and_three_seconds', new Cassandra\Duration(2, 12, 3 * (1000 ** 3)))
+      );
+
+      foreach ($durations as $duration) {
+          $options = array('arguments' => $duration);
+          $session->execute("INSERT INTO duration (k, d) VALUES (?, ?)", $options);
+      }
+
+      $rows = $session->execute("SELECT * FROM duration");
+
+      foreach ($rows as $row) {
+        echo "{$row['k']}: {$row['d']}" . PHP_EOL;
+      }
+      """
+    When it is executed
+    Then its output should contain these lines in any order:
+      """
+      twelve_hours: 0mo12d0ns
+      three_seconds: 0mo0d3000000000ns
+      two_days_twelve_hours_and_three_seconds: 2mo12d3000000000ns
+      two_days: 2mo0d0ns
+      """
+

Diff for: features/duration_collections.feature

@@ -0,0 +1,74 @@
+@cassandra-version-3.10
+Feature: Duration
+
+  PHP Driver supports the `Duration` datatype in collections
+
+  Background:
+    Given a running Cassandra cluster
+
+  Scenario: Use the duration type in collections
+    Given the following schema:
+      """cql
+      CREATE KEYSPACE simplex WITH replication = {
+        'class': 'SimpleStrategy',
+        'replication_factor': 1
+      };
+      USE simplex;
+      CREATE TYPE duration_user_type (duration1 duration, duration2 duration);
+      CREATE TABLE durations (k text PRIMARY KEY,
+                              duration_list list<duration>,
+                              duration_tuple tuple<duration, duration>,
+                              duration_udt duration_user_type);
+      """
+    And the following example:
+      """
+      <?php
+      $cluster = Cassandra::cluster()->build();
+      $session = $cluster->connect("simplex");
+
+      # Construct collection arguments
+
+      $list = Cassandra\Type::collection(Cassandra\Type::duration())->create(
+          new Cassandra\Duration(1, 2, 3)
+      );
+      $list->add(new Cassandra\Duration(4, 5, 6));
+
+      $tuple = Cassandra\Type::tuple(Cassandra\Type::duration(), Cassandra\Type::duration())->create(
+          new Cassandra\Duration(1, 2, 3), new Cassandra\Duration(4, 5, 6)
+      );
+
+      $udt = Cassandra\Type::userType('duration1', Cassandra\Type::duration(), 'duration2', Cassandra\Type::duration())->create(
+          'duration1', new Cassandra\Duration(1, 2, 3)
+      );
+      $udt->set('duration2', new Cassandra\Duration(4, 5, 6));
+
+
+      # Insert collections containing durations into table
+      $options = array('arguments' =>
+          array('key1', $list, $tuple, $udt)
+      );
+      $session->execute("INSERT INTO durations
+          (k, duration_list, duration_tuple, duration_udt) VALUES
+          (?, ?, ?, ?)", $options);
+      # Select collections from table and print as WKT
+      $rows = $session->execute("SELECT * FROM durations WHERE k = 'key1'");
+      $row = $rows->first();
+
+
+      $rows = $session->execute("SELECT * FROM durations WHERE k = 'key1'");
+      $row = $rows->first();
+
+      echo 'The list contains durations: [' . implode(', ', $row['duration_list']->values()) . ']' . PHP_EOL;
+      echo 'The tuple contains durations: (' . implode(', ', $row['duration_tuple']->values()) . ')' . PHP_EOL;
+      $asWkt = array_map(function($k, $v) { return $k . ': ' . $v; },
+          array_keys($row["duration_udt"]->values()), $row["duration_udt"]->values());
+      echo 'The udt contains durations: {' . implode(', ', $asWkt) . '}' . PHP_EOL;
+      """
+    When it is executed
+    Then its output should contain these lines in any order:
+      """
+      The list contains durations: [1mo2d3ns, 4mo5d6ns]
+      The tuple contains durations: (1mo2d3ns, 4mo5d6ns)
+      The udt contains durations: {duration1: 1mo2d3ns, duration2: 4mo5d6ns}
+      """
+

Diff for: lib/cpp-driver

@@ -112,7 +112,8 @@ public function scalarTypes()
             array(Type::timeuuid(), new Timeuuid(0)),
             array(Type::uuid(), new Uuid("03398c99-c635-4fad-b30a-3b2c49f785c2")),
             array(Type::varchar(), "varchar"),
-            array(Type::varint(), new Varint("9223372036854775808"))
+            array(Type::varint(), new Varint("9223372036854775808")),
+            array(Type::duration(), new Duration(1, 2, 3))
         );
     }