durable_rules 0.34.51 → 0.34.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9db587bb8df6b72055812d37c3b3db5e1bebba8f
-  data.tar.gz: 3f35d2c234db4ae3c5d50619a52e743b0146f051
+  metadata.gz: 72027204669b6fba94f9092c272f05e27e6d7b1f
+  data.tar.gz: 377a4eb20f2ae9fb966380bdcfb1f91e72b85de4
 SHA512:
-  metadata.gz: 55c856dd6335c44e34fb5b85d88d74c1443e3fde82ee1b3c798feb1bd5b52c06bda645c1922bbcb69ee0a6ff2ec98592bcb68e864b1a57e77a9ec043f356c46e
-  data.tar.gz: b74146ddba7bd15e620b652ca0a0138244dfc4bce8dc95356fc082e37b1ee89c1dac7e0fe469aee5a75045414e8a6861cc725117b34678667db7a7a2b091bfe9
+  metadata.gz: 2b61ad9e9c4343ec0edaa7ebd0cc5d68c9613b206331c1d64eb31c5bde6b5f617d6a7f38ea0181a83e956edebcaa82aab5ad4ecd3d66da1bbba9202f24c621a9
+  data.tar.gz: bd8b882feea47d4ba40f40301e310499c37f3828fb3400a9e766432faf311ca184d936099da9b424c14b073c0c3311d0b6e26f5031f1f1159e455b17962620c3

data/librb/durable.rb

@@ -449,6 +449,10 @@ module Durable
       {:cap => value}
     end
 
+    def distinct(value)
+      {:dist => value}
+    end
+
     def timeout(name)
       expression = Expression.new(:$m, :$t)
       expression == name
@@ -507,6 +511,14 @@ module Durable
         rule["cap"] = options[:cap]
       end
 
+      if options.key? :dist
+        if (options[:dist])
+          rule["dist"] = 1
+        else
+          rule["dist"] = 0
+        end
+      end
+
       @rules[rule_name] = rule
       rule
     end

data/src/rules/net.c

@@ -282,8 +282,14 @@ static unsigned int createTest(ruleset *tree, expression *expr, char **test, cha
             }
             
             if (first) {
-                if (asprintf(test, "%scompare_array(message[\"%s\"], %s, %s, %s)", *test, leftProperty, idiomString, op, par)  == -1) {
-                    return ERR_OUT_OF_MEMORY;
+                if (expr->distinct) {
+                    if (asprintf(test, "is_distinct_message(frame, message) and %scompare_array(message[\"%s\"], %s, %s, %s)", *test, leftProperty, idiomString, op, par)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
+                } else {
+                    if (asprintf(test, "%scompare_array(message[\"%s\"], %s, %s, %s)", *test, leftProperty, idiomString, op, par)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
                 }
                 
                 first = 0;
@@ -330,9 +336,16 @@ static unsigned int createTest(ruleset *tree, expression *expr, char **test, cha
 
             char *oldTest = *test;
             if (first) {
-                if (asprintf(test, "%smessage[\"%s\"] %s %s", *test, leftProperty, op, idiomString)  == -1) {
-                    return ERR_OUT_OF_MEMORY;
+                if (expr->distinct) {
+                    if (asprintf(test, "is_distinct_message(frame, message) and %smessage[\"%s\"] %s %s", *test, leftProperty, op, idiomString)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
+                } else {
+                    if (asprintf(test, "%smessage[\"%s\"] %s %s", *test, leftProperty, op, idiomString)  == -1) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
                 }
+
                 first = 0;
             } else {
                 if (asprintf(test, "%s %s message[\"%s\"] %s %s", *test, comp, leftProperty, op, idiomString) == -1) {
@@ -768,6 +781,45 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
 "local message = {}\n"
 "local primary_message_keys = {}\n"
 "local input_keys = {}\n"
+"local is_distinct_message = function(frame, message)\n"
+"   for name, frame_message in pairs(frame) do\n"
+"       if frame_message[\"id\"] == message[\"id\"] then\n"
+"           return false\n"
+"       end\n"    
+"   end\n"
+"   return true\n"
+"end\n"
+"local compare_array = function(left_array, right_value, op, compare_all)\n"
+"   if not left_array or type(left_array) ~= \"table\" then\n"
+"        return false\n"
+"   end\n"
+"   for i = 1, #left_array, 1 do\n"
+"       local comparison = false\n"
+"       if op == 0 then\n"
+"           comparison = (left_array[i] < right_value)\n"
+"       elseif op == 1 then\n"
+"           comparison = (left_array[i] <= right_value)\n"
+"       elseif op == 2 then\n"
+"           comparison = (left_array[i] > right_value)\n"
+"       elseif op == 3 then\n"
+"           comparison = (left_array[i] >= right_value)\n"
+"       elseif op == 4 then\n"
+"           comparison = (left_array[i] == right_value)\n"
+"       elseif op == 5 then\n"
+"           comparison = (left_array[i] ~= right_value)\n"
+"       end\n"
+"       if not compare_all and comparison then\n"
+"           return true\n"
+"       end\n"
+"       if compare_all and not comparison then\n"
+"           return false\n"
+"       end\n"
+"   end"
+"   if compare_all then\n"
+"       return true\n"
+"   end\n"
+"   return false\n"
+"end\n"
 "local save_message = function(current_key, message, events_key, messages_key, save_hashset)\n"
 "    if save_hashset == 1 then\n"
 "        redis.call(\"hsetnx\", messages_key, message[\"id\"], cmsgpack.pack(message))\n"
@@ -1045,6 +1097,14 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
 "local facts_mids_cache = {}\n"
 "local events_mids_cache = {}\n"
 "local get_context\n"
+"local is_distinct_message = function(frame, message)\n"
+"   for name, frame_message in pairs(frame) do\n"
+"       if frame_message[\"id\"] == message[\"id\"] then\n"
+"           return false\n"
+"       end\n"    
+"   end\n"
+"   return true\n"
+"end\n"
 "local compare_array = function(left_array, right_value, op, compare_all)\n"
 "   if not left_array or type(left_array) ~= \"table\" then\n"
 "        return false\n"
@@ -1837,6 +1897,14 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "local results_key\n"
 "local inverse_directory\n"
 "local key\n"
+"local is_distinct_message = function(frame, message)\n"
+"   for name, frame_message in pairs(frame) do\n"
+"       if frame_message[\"id\"] == message[\"id\"] then\n"
+"           return false\n"
+"       end\n"    
+"   end\n"
+"   return true\n"
+"end\n"
 "local compare_array = function(left_array, right_value, op, compare_all)\n"
 "   if not left_array or type(left_array) ~= \"table\" then\n"
 "        return false\n"

data/src/rules/rete.c

@@ -13,6 +13,7 @@
 #define HASH_PRI 1450887882 // pri
 #define HASH_COUNT 967958004 // count
 #define HASH_CAP 41178555 // cap
+#define HASH_DIST 1281379241 // dist
 #define HASH_LT 542787579 // $lt
 #define HASH_LTE 2350824890 // $lte
 #define HASH_GT 507407960 // $gt
@@ -67,6 +68,7 @@ static unsigned int validateAlgebra(char *rule);
 static unsigned int createBeta(ruleset *tree, 
                                char *rule, 
                                unsigned char operator, 
+                               unsigned short distinct,
                                unsigned int nextOffset, 
                                path *nextPath, 
                                path **outPath);
@@ -796,6 +798,11 @@ static unsigned int validateRuleset(char *rules) {
             return result;
         }
 
+        result = validateSetting(HASH_DIST, first, JSON_INT);
+        if (result != PARSE_OK && result != ERR_SETTING_NOT_FOUND) {
+            return result;
+        }
+
         result = readNextName(first, &first, &last, &hash);
         while (result == PARSE_OK) {
             result = readNextValue(last, &first, &last, &type);
@@ -808,7 +815,8 @@ static unsigned int validateRuleset(char *rules) {
                 if (result != RULES_OK && result != PARSE_END) {
                     return result;
                 }
-            } else if (hash != HASH_COUNT && hash != HASH_PRI && hash != HASH_CAP) {
+            } else if (hash != HASH_COUNT && hash != HASH_PRI && hash != HASH_CAP && hash != HASH_DIST) {
+                printf("%d\n", hash);
                 return ERR_UNEXPECTED_NAME;
             }
 
@@ -1360,6 +1368,7 @@ static unsigned int createAlpha(ruleset *tree,
 static unsigned int createBetaConnector(ruleset *tree, 
                                         char *rule, 
                                         path *betaPath,
+                                        unsigned short distinct,
                                         unsigned int nextOffset) {
     char *first;
     char *last;
@@ -1429,6 +1438,7 @@ static unsigned int createBetaConnector(ruleset *tree,
         expr->not = (operator == OP_NOT) ? 1 : 0;
         expr->termsLength = 0;
         expr->t.termsPointer = NULL;
+        expr->distinct = (distinct != 0) ? 1 : 0;
         if (operator == OP_NOP || operator == OP_NOT) {
             unsigned int resultOffset = NODE_M_OFFSET;
             readNextValue(last, &first, &last, &type);
@@ -1436,7 +1446,7 @@ static unsigned int createBetaConnector(ruleset *tree,
         }
         else {
             readNextValue(last, &first, &last, &type);
-            result = createBeta(tree, first, operator, connectorOffset, betaPath, NULL);
+            result = createBeta(tree, first, operator, distinct, connectorOffset, betaPath, NULL);
         }
 
         if (result != RULES_OK) {
@@ -1452,6 +1462,7 @@ static unsigned int createBetaConnector(ruleset *tree,
 static unsigned int createBeta(ruleset *tree, 
                                char *rule, 
                                unsigned char operator, 
+                               unsigned short distinct,
                                unsigned int nextOffset, 
                                path *nextPath, 
                                path **outPath) {
@@ -1496,7 +1507,7 @@ static unsigned int createBeta(ruleset *tree,
         *outPath = betaPath;
     }
 
-    return createBetaConnector(tree, rule, betaPath, nextOffset);    
+    return createBetaConnector(tree, rule, betaPath, distinct, nextOffset);    
 }
 
 static unsigned int add(any *right, any *left, any **result) {
@@ -1604,6 +1615,7 @@ static unsigned int createSingleQuery(ruleset *tree,
     newExpression->aliasOffset = expr->aliasOffset;
     newExpression->termsLength = expr->termsLength;
     newExpression->not = expr->not;
+    newExpression->distinct = expr->distinct;
     if (expr->termsLength) {
         result = allocateNext(tree, expr->termsLength, &newExpression->t.termsOffset);
         if (result != RULES_OK) {
@@ -1851,15 +1863,17 @@ static unsigned int createTree(ruleset *tree, char *rules) {
             ruleAction->value.c.count = 1;
         }
 
+        unsigned short distinct = 1;
+        getSetting(HASH_DIST, first, &distinct);
         result = readNextName(first, &first, &last, &hash);
         while (result == PARSE_OK) {
             readNextValue(last, &first, &last, &type);
             switch (hash) {
                 case HASH_ANY:
-                    result = createBeta(tree, first, OP_ANY, actionOffset, NULL, &betaPath);
+                    result = createBeta(tree, first, OP_ANY, distinct, actionOffset, NULL, &betaPath);
                     break;
                 case HASH_ALL:
-                    result = createBeta(tree, first, OP_ALL, actionOffset, NULL, &betaPath);
+                    result = createBeta(tree, first, OP_ALL, distinct, actionOffset, NULL, &betaPath);
                     break;
             }
             if (result != RULES_OK) {

data/src/rules/rete.h

@@ -66,6 +66,7 @@ typedef struct expression {
     unsigned int nameOffset;
     unsigned int aliasOffset;
     unsigned short termsLength;
+    unsigned char distinct;
     unsigned char not;
     union {
         unsigned int termsOffset; 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.51
+  version: 0.34.52
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-01 00:00:00.000000000 Z
+date: 2018-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake