Adding support for filtering on array column types

dockerfiles/db/setup.sql

@@ -58,6 +58,7 @@ create table blog_post(
     blog_id integer not null references blog(id) on delete cascade,
     title varchar(255) not null,
     body varchar(10000),
+    tags TEXT[],
     status blog_post_status not null,
     created_at timestamp not null
 );
@@ -79,5 +80,15 @@ values
     ((select id from account where email ilike 'a%'), 'A: Blog 3', 'a desc3', now()),
     ((select id from account where email ilike 'b%'), 'B: Blog 3', 'b desc1', now());
 
+insert into blog_post (blog_id, title, body, tags, status, created_at)
+values
+    ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 1 in A Blog 1', 'Content for post 1 in A Blog 1', '{"tech", "update"}', 'RELEASED', NOW()),
+    ((SELECT id FROM blog WHERE name = 'A: Blog 1'), 'Post 2 in A Blog 1', 'Content for post 2 in A Blog 1', '{"announcement", "tech"}', 'PENDING', NOW()),
+    ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 1 in A Blog 2', 'Content for post 1 in A Blog 2', '{"personal"}', 'RELEASED', NOW()),
+    ((SELECT id FROM blog WHERE name = 'A: Blog 2'), 'Post 2 in A Blog 2', 'Content for post 2 in A Blog 2', '{"update"}', 'RELEASED', NOW()),
+    ((SELECT id FROM blog WHERE name = 'A: Blog 3'), 'Post 1 in A Blog 3', 'Content for post 1 in A Blog 3', '{"travel", "adventure"}', 'PENDING', NOW()),
+    ((SELECT id FROM blog WHERE name = 'B: Blog 3'), 'Post 1 in B Blog 3', 'Content for post 1 in B Blog 3', '{"tech", "review"}', 'RELEASED', NOW()),
+    ((SELECT id FROM blog WHERE name = 'B: Blog 3'), 'Post 2 in B Blog 3', 'Content for post 2 in B Blog 3', '{"coding", "tutorial"}', 'PENDING', NOW());
+
 
 comment on schema public is '@graphql({"inflect_names": true})';

src/builder.rs

@@ -1085,7 +1085,7 @@ fn create_filters(
     let kv_map = match validated {
         gson::Value::Absent | gson::Value::Null => return Ok(filters),
         gson::Value::Object(kv) => kv,
-        _ => return Err("Filter re-validation errror".to_string()),
+        _ => return Err("Filter re-validation error".to_string()),
     };
 
     for (k, op_to_v) in kv_map {
@@ -1137,7 +1137,7 @@ fn create_filters(
                     }
                 }
             }
-            gson::Value::Array(values) if k == AND_FILTER_NAME || k == OR_FILTER_NAME => {
+            gson::Value::Array(values) => if k == AND_FILTER_NAME || k == OR_FILTER_NAME {
                 // If there are no inner filters we avoid creating an argumentless `and`/`or` expression
                 // which would have been anyways compiled away during transpilation
                 if !values.is_empty() {
@@ -1171,8 +1171,27 @@ fn create_filters(
 
                     filters.push(filter_builder);
                 }
+            } else {
+                if !values.is_empty() {
+                    for value in values {
+                        if let gson::Value::Object(filter_op_to_value_map) = value {
+                            for (filter_op_str, filter_val) in filter_op_to_value_map {
+                                let filter_op = FilterOp::from_str(filter_op_str)?;
+
+                                // Skip absent
+                                // Technically nulls should be treated as literals. It will always filter out all rows
+                                // val <op> null is never true
+                                if filter_val == &gson::Value::Absent {
+                                    continue;
+                                }
+
+                                filters.push(create_filter_builder_elem(filter_iv, filter_op, filter_val)?);
+                            }
+                        }
+                    }
+                }
             }
-            _ => return Err("Filter re-validation errror op_to_value map".to_string()),
+            _ => return Err("Filter re-validation error op_to_value map".to_string()),
         }
     }
     Ok(filters)

src/graphql.rs

@@ -1116,6 +1116,7 @@ pub struct OrderByEntityType {
 pub enum FilterableType {
     Scalar(Scalar),
     Enum(EnumType),
+    List(ListType),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
@@ -1129,6 +1130,10 @@ impl FilterTypeType {
         match &self.entity {
             FilterableType::Scalar(s) => s.name().expect("scalar name should exist"),
             FilterableType::Enum(e) => e.name().expect("enum type name should exist"),
+            FilterableType::List(l) => match l.of_type().unwrap().name() {
+                None => panic!("inner list type name should exist"),
+                Some(name) => format!("{}List", name)
+            },
         }
     }
 }
@@ -3328,6 +3333,9 @@ pub enum FilterOp {
     ILike,
     RegEx,
     IRegEx,
+    Contains,
+    ContainedBy,
+    Overlap,
 }
 
 impl ToString for FilterOp {
@@ -3346,6 +3354,9 @@ impl ToString for FilterOp {
             Self::ILike => "ilike",
             Self::RegEx => "regex",
             Self::IRegEx => "iregex",
+            Self::Contains => "cs",
+            Self::ContainedBy => "cd",
+            Self::Overlap => "ov",
         }
         .to_string()
     }
@@ -3369,6 +3380,9 @@ impl FromStr for FilterOp {
             "ilike" => Ok(Self::ILike),
             "regex" => Ok(Self::RegEx),
             "iregex" => Ok(Self::IRegEx),
+            "cs" => Ok(Self::Contains),
+            "cd" => Ok(Self::ContainedBy),
+            "ov" => Ok(Self::Overlap),
             _ => Err("Invalid filter operation".to_string()),
         }
     }
@@ -3541,6 +3555,8 @@ impl ___Type for FilterTypeType {
                             default_value: None,
                             sql_type: None,
                         },
+                        // shouldn't happen since we've covered all cases in supported_ops
+                        _ => panic!("encountered unknown FilterOp")
                     })
                     .collect()
             }
@@ -3583,6 +3599,36 @@ impl ___Type for FilterTypeType {
                     },
                 ]
             }
+            FilterableType::List(list_type) => {
+                let supported_ops = vec![
+                    FilterOp::Contains,
+                    FilterOp::ContainedBy,
+                    FilterOp::Equal,
+                    FilterOp::GreaterThan,
+                    FilterOp::GreaterThanEqualTo,
+                    FilterOp::LessThan,
+                    FilterOp::LessThanEqualTo,
+                    FilterOp::NotEqual,
+                    FilterOp::Overlap,
+                ];
+
+                supported_ops
+                    .iter()
+                    .map(|op| match op {
+                        _ => __InputValue {
+                            name_: op.to_string(),
+                            type_: __Type::List(ListType {
+                                type_: Box::new(__Type::NonNull(NonNullType {
+                                    type_: Box::new(*list_type.type_.clone()),
+                                })),
+                            }),
+                            description: None,
+                            default_value: None,
+                            sql_type: None,
+                        },
+                    })
+                    .collect()
+            }
         };
 
         infields.sort_by_key(|a| a.name());
@@ -3620,14 +3666,11 @@ impl ___Type for FilterEntityType {
             .columns
             .iter()
             .filter(|x| x.permissions.is_selectable)
-            // No filtering on arrays
-            .filter(|x| !x.type_name.ends_with("[]"))
             // No filtering on composites
             .filter(|x| !self.schema.context.is_composite(x.type_oid))
             // No filtering on json/b. they do not support = or <>
             .filter(|x| !["json", "jsonb"].contains(&x.type_name.as_ref()))
             .filter_map(|col| {
-                // Should be a scalar
                 if let Some(utype) = sql_column_to_graphql_type(col, &self.schema) {
                     let column_graphql_name = self.schema.graphql_column_field_name(col);
 
@@ -3641,22 +3684,33 @@ impl ___Type for FilterEntityType {
                         not_column_exists = true;
                     }
 
-                    match utype.unmodified_type() {
-                        __Type::Scalar(s) => Some(__InputValue {
+                    match utype.nullable_type() {
+                        __Type::Scalar(s) => {
+                            Some(__InputValue {
+                                name_: column_graphql_name,
+                                type_: __Type::FilterType(FilterTypeType {
+                                    entity: FilterableType::Scalar(s),
+                                    schema: Arc::clone(&self.schema),
+                                }),
+                                description: None,
+                                default_value: None,
+                                sql_type: Some(NodeSQLType::Column(Arc::clone(col))),
+                            })
+                        },
+                        __Type::Enum(e) => Some(__InputValue {
                             name_: column_graphql_name,
                             type_: __Type::FilterType(FilterTypeType {
-                                entity: FilterableType::Scalar(s),
+                                entity: FilterableType::Enum(e),
                                 schema: Arc::clone(&self.schema),
                             }),
                             description: None,
                             default_value: None,
                             sql_type: Some(NodeSQLType::Column(Arc::clone(col))),
                         }),
-                        // ERROR HERE
-                        __Type::Enum(s) => Some(__InputValue {
+                        __Type::List(l) => Some(__InputValue {
                             name_: column_graphql_name,
                             type_: __Type::FilterType(FilterTypeType {
-                                entity: FilterableType::Enum(s),
+                                entity: FilterableType::List(l),
                                 schema: Arc::clone(&self.schema),
                             }),
                             description: None,
@@ -3829,13 +3883,12 @@ impl ___Type for OrderByEntityType {
                 .columns
                 .iter()
                 .filter(|x| x.permissions.is_selectable)
-                // No filtering on arrays
+                // No ordering by arrays
                 .filter(|x| !x.type_name.ends_with("[]"))
-                // No filtering on composites
+                // No ordering by composites
                 .filter(|x| !self.schema.context.is_composite(x.type_oid))
-                // No filtering on json/b. they do not support = or <>
+                // No ordering by json/b. they do not support = or <>
                 .filter(|x| !["json", "jsonb"].contains(&x.type_name.as_ref()))
-                // TODO  filter out arrays, json and composites
                 .map(|col| __InputValue {
                     name_: self.schema.graphql_column_field_name(col),
                     type_: __Type::OrderBy(OrderByType {}),
@@ -3968,6 +4021,72 @@ impl __Schema {
                 entity: FilterableType::Scalar(Scalar::Opaque),
                 schema: Arc::clone(&schema_rc),
             }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::ID))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::Int))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::Float))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::String(None)))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::Boolean))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::Date))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::Time))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::Datetime))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::BigInt))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::UUID))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
+            __Type::FilterType(FilterTypeType {
+                entity: FilterableType::List(ListType {
+                    type_: Box::new(__Type::Scalar(Scalar::BigFloat))
+                }),
+                schema: Arc::clone(&schema_rc),
+            }),
             __Type::Query(QueryType {
                 schema: Arc::clone(&schema_rc),
             }),

src/transpile.rs

@@ -714,6 +714,9 @@ impl FilterBuilderElem {
                     _ => {
                         let cast_type_name = match op {
                             FilterOp::In => format!("{}[]", column.type_name),
+                            FilterOp::Contains => format!("{}[]", column.type_name),
+                            FilterOp::ContainedBy => format!("{}[]", column.type_name),
+                            FilterOp::Overlap => format!("{}[]", column.type_name),
                             _ => column.type_name.clone(),
                         };
 
@@ -735,6 +738,9 @@ impl FilterBuilderElem {
                                 FilterOp::ILike => "ilike",
                                 FilterOp::RegEx => "~",
                                 FilterOp::IRegEx => "~*",
+                                FilterOp::Contains => "@>",
+                                FilterOp::ContainedBy => "<@",
+                                FilterOp::Overlap => "&&",
                                 FilterOp::Is => {
                                     return Err("Error transpiling Is filter".to_string());
                                 }

test/expected/omit_exotic_types.out

@@ -1,8 +1,7 @@
 begin;
     /*
-        Composite and array types are not currently supported as inputs
+        Composite types are not currently supported as inputs
         - confirm composites are not allowed anywhere
-        - confirm arrays are not allowed as input
     */
     create type complex as (r int, i int);
     create table something(
@@ -107,6 +106,9 @@ begin;
          {                             +
              "name": "name"            +
          },                            +
+         {                             +
+             "name": "tags"            +
+         },                            +
          {                             +
              "name": "nodeId"          +
          },                            +