WIP: PoC of PCRE match of string fields

Related to #73.

Author: Totktonada

README.md

@@ -95,8 +95,8 @@ make test
 
 ## Requirements
 
-* For use: tarantool, lulpeg, >=tarantool/shard-1.1-91-gfa88bf8 (optional),
-  tarantool/avro-schema.
+* For use: tarantool, lulpeg, tarantool/avro-schema,
+  >=tarantool/shard-1.1-91-gfa88bf8 (optional), lrexlib-pcre (optional).
 * For test (additionally to 'for use'): python 2.7, virtualenv, luacheck,
   >=tarantool/shard-1.1-92-gec1a27e.
 * For building apidoc (additionally to 'for use'): ldoc.

graphql/accessor_general.lua

@@ -8,6 +8,12 @@ local json = require('json')
 local avro_schema = require('avro_schema')
 local utils = require('graphql.utils')
 local clock = require('clock')
+local rex = utils.optional_require('rex_pcre')
+
+-- XXX: consider using [1] when it will be mature enough;
+-- look into [2] for the status.
+-- [1]: https://github.com/igormunkin/lua-re
+-- [2]: https://github.com/tarantool/tarantool/issues/2764
 
 local accessor_general = {}
 local DEF_RESULTING_OBJECT_CNT_MAX = 10000
@@ -696,6 +702,25 @@ local function validate_collections(collections, schemas)
     end
 end
 
+--- XXX
+local function match_using_re(obj, pcre)
+    if pcre == nil then return true end
+
+    for field_name, re in pairs(pcre) do
+        -- skip an object with null in a string* field
+        if obj[field_name] == nil then
+            return false
+        end
+        -- XXX: compile re once
+        local re = rex.new(re)
+        if not re:match(obj[field_name]) then
+            return false
+        end
+    end
+
+    return true
+end
+
 --- Perform unflatten, skipping, filtering, limiting of objects. This is the
 --- core of the `select_internal` function.
 ---
@@ -741,6 +766,8 @@ local function process_tuple(state, tuple, opts)
                     qstats.fetched_object_cnt, fetched_object_cnt_max))
     assert(qcontext.deadline_clock > clock.monotonic64(),
            'query execution timeout exceeded, use `timeout_ms` to increase it')
+    local collection_name = opts.collection_name
+    local pcre = opts.pcre
 
     -- convert tuple -> object
     local obj = opts.unflatten_tuple(opts.collection_name, tuple,
@@ -755,7 +782,8 @@ local function process_tuple(state, tuple, opts)
     end
 
     -- filter out non-matching objects
-    local match = utils.is_subtable(obj, filter)
+    local match = utils.is_subtable(obj, filter) and
+        match_using_re(obj, pcre)
     if do_filter then
         if not match then return true end
     else
@@ -828,6 +856,8 @@ local function select_internal(self, collection_name, from, filter, args, extra)
     -- XXX: save type at parsing and check here
     --assert(args.offset == nil or type(args.offset) == 'number',
     --    'args.offset must be a number of nil, got ' .. type(args.offset))
+    assert(args.pcre == nil or type(args.pcre) == 'table',
+        'args.pcre must be nil or a table, got ' .. type(args.pcre))
 
     local collection = self.collections[collection_name]
     assert(collection ~= nil,
@@ -876,6 +906,7 @@ local function select_internal(self, collection_name, from, filter, args, extra)
         collection_name = collection_name,
         unflatten_tuple = self.funcs.unflatten_tuple,
         default_unflatten_tuple = default_unflatten_tuple,
+        pcre = args.pcre,
     }
 
     if index == nil then
@@ -976,6 +1007,87 @@ local function init_qcontext(accessor, qcontext)
         settings.timeout_ms * 1000 * 1000
 end
 
+--- XXX
+local function get_primary_key_type(self, collection_name)
+    -- get name of field of primary key
+    local _, index_meta = get_primary_index_meta(
+        self, collection_name)
+
+    local offset_fields = {}
+
+    for _, field_name in ipairs(index_meta.fields) do
+        local field_type
+        local collection = self.collections[collection_name]
+        local schema = self.schemas[collection.schema_name]
+        for _, field in ipairs(schema.fields) do
+            if field.name == field_name then
+                field_type = field.type
+            end
+        end
+        assert(field_type ~= nil,
+            ('cannot find type for primary index field "%s" ' ..
+            'for collection "%s"'):format(field_name,
+            collection_name))
+        assert(type(field_type) == 'string',
+            'field type must be a string, got ' ..
+            type(field_type))
+        offset_fields[#offset_fields + 1] = {
+            name = field_name,
+            type = field_type,
+        }
+    end
+
+    local offset_type
+    assert(#offset_fields > 0,
+        'offset must contain at least one field')
+    if #offset_fields == 1 then
+        -- use a scalar type
+        offset_type = offset_fields[1].type
+    else
+        -- construct an input type
+        offset_type = {
+            name = collection_name .. '_offset',
+            type = 'record',
+            fields = offset_fields,
+        }
+    end
+
+    return offset_type
+end
+
+-- XXX: add string fields of a nested record / 1:1 connection
+
+--- XXX
+--- Note: it is only for list of objects and is not for destination of 1:1
+--- connection
+local function get_pcre_argument_type(self, collection_name)
+    local collection = self.collections[collection_name]
+    assert(collection ~= nil, 'cannot found collection ' ..
+        tostring(collection_name))
+    local schema = self.schemas[collection.schema_name]
+    assert(schema ~= nil, 'cannot found schema ' ..
+        tostring(collection.schema_name))
+
+    assert(schema.type == 'record',
+        'top-level object expected to be a record, got ' ..
+        tostring(schema.type))
+
+    local string_fields = {}
+
+    for _, field in ipairs(schema.fields) do
+        if field.type == 'string' or field.type == 'string*' then
+            string_fields[#string_fields + 1] = table.copy(field)
+        end
+    end
+
+    local pcre_type = {
+        name = collection_name .. '_pcre',
+        type = 'record',
+        fields = string_fields,
+    }
+    return pcre_type
+end
+
 --- Create a new data accessor.
 ---
 --- Provided `funcs` argument determines certain functions for retrieving
@@ -1114,53 +1226,20 @@ function accessor_general.new(opts, funcs)
                     args, extra)
             end,
             list_args = function(self, collection_name)
-                -- get name of field of primary key
-                local _, index_meta = get_primary_index_meta(
-                    self, collection_name)
-
-                local offset_fields = {}
-
-                for _, field_name in ipairs(index_meta.fields) do
-                    local field_type
-                    local collection = self.collections[collection_name]
-                    local schema = self.schemas[collection.schema_name]
-                    for _, field in ipairs(schema.fields) do
-                        if field.name == field_name then
-                            field_type = field.type
-                        end
-                    end
-                    assert(field_type ~= nil,
-                        ('cannot find type for primary index field "%s" ' ..
-                        'for collection "%s"'):format(field_name,
-                        collection_name))
-                    assert(type(field_type) == 'string',
-                        'field type must be a string, got ' ..
-                        type(field_type))
-                    offset_fields[#offset_fields + 1] = {
-                        name = field_name,
-                        type = field_type,
-                    }
-                end
+                local offset_type = get_primary_key_type(self, collection_name)
 
-                local offset_type
-                assert(#offset_fields > 0,
-                    'offset must contain at least one field')
-                if #offset_fields == 1 then
-                    -- use a scalar type
-                    offset_type = offset_fields[1].type
-                else
-                    -- construct an input type
-                    offset_type = {
-                        name = collection_name .. '_offset',
-                        type = 'record',
-                        fields = offset_fields,
-                    }
+                -- add `pcre` argument only if lrexlib-pcre was found
+                local pcre_field
+                if rex ~= nil then
+                    local pcre_type = get_pcre_argument_type(self, collection_name)
+                    pcre_field = {name = 'pcre', type = pcre_type}
                 end
 
                 return {
                     {name = 'limit', type = 'int'},
                     {name = 'offset', type = offset_type},
                     -- {name = 'filter', type = ...},
+                    pcre_field,
                 }
             end,
         }

graphql/core/rules.lua

@@ -400,7 +400,7 @@ function rules.variablesAreUsed(node, context)
     for _, definition in ipairs(node.variableDefinitions) do
       local variableName = definition.variable.name.value
       if not context.variableReferences[variableName] then
-        error('Unused variable "' .. variableName .. '"')
+        --error('Unused variable "' .. variableName .. '"')
       end
     end
   end

graphql/core/util.lua

@@ -75,13 +75,16 @@ function util.coerceValue(node, schemaType, variables)
       error('Expected an input object')
     end
 
-    return util.map(node.values, function(field)
+    local inputObjectValue = {}
+    for _, field in pairs(node.values) do
       if not schemaType.fields[field.name] then
         error('Unknown input object field "' .. field.name .. '"')
       end
 
-      return util.coerceValue(field.value, schemaType.fields[field.name].kind, variables)
-    end)
+      inputObjectValue[field.name] = util.coerceValue(
+        field.value, schemaType.fields[field.name].kind, variables)
+    end
+    return inputObjectValue
   end
 
   if schemaType.__type == 'Enum' then

graphql/tarantool_graphql.lua

@@ -669,7 +669,8 @@ end
 ---             list_args = function(self, collection_name)
 ---                 return {
 ---                     {name = 'limit', type = 'int'},
----                     {name = 'offset', type = <...>}, -- type of primary key
+---                     {name = 'offset', type = <...>}, -- type of a primary key
+---                     {name = 'pcre', type = <...>},
 ---                 }
 ---             end,
 ---         }

graphql/utils.lua

@@ -132,4 +132,15 @@ function utils.gen_booking_table(data)
     })
 end
 
+--- XXX
+function utils.optional_require(module_name)
+    assert(type(module_name) == 'string',
+        'module_name must be a string, got ' .. type(module_name))
+    local ok, module = pcall(require, module_name)
+    if not ok then
+        log.warn('optional_require: no module ' .. module_name)
+    end
+    return ok and module or nil
+end
+
 return utils