{"record":{"id":"63638089de0cef53","repo":"hasura/graphql-engine","slug":"the-data-connector-data-connector-name-does-no-636380","errorCode":null,"errorMessage":"The data connector '{data_connector_name}' does not support filtering by nested scalar arrays. The comparable field '{field_name}' within '{boolean_expression_type_name}' is of a scalar array type: {field_type}","messagePattern":"The data connector '(.+?)' does not support filtering by nested scalar arrays\\. The comparable field '(.+?)' within '(.+?)' is of a scalar array type: (.+?)","errorType":"validation","errorClass":"BooleanExpressionIssue::DataConnectorDoesNotSupportNestedScalarArrayFiltering","httpStatus":null,"severity":"warning","filePath":"v3/crates/metadata-resolve/src/stages/boolean_expressions/types.rs","lineNumber":35,"sourceCode":"use ref_cast::RefCast;\nuse serde::{Deserialize, Serialize};\nuse serde_with::serde_as;\nuse std::collections::{BTreeMap, BTreeSet};\nuse std::fmt::Display;\nuse std::sync::Arc;\n\n#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq)]\npub enum BooleanExpressionIssue {\n    #[error(\n        \"The data connector '{data_connector_name}' does not support filtering by nested object arrays. The comparable field '{field_name}' within {boolean_expression_type_name}' is of an object array type: {field_type}\"\n    )]\n    DataConnectorDoesNotSupportNestedObjectArrayFiltering {\n        data_connector_name: Qualified<DataConnectorName>,\n        boolean_expression_type_name: Qualified<CustomTypeName>,\n        field_name: FieldName,\n        field_type: QualifiedTypeReference,\n    },\n    #[error(\n        \"The data connector '{data_connector_name}' does not support filtering by nested scalar arrays. The comparable field '{field_name}' within '{boolean_expression_type_name}' is of a scalar array type: {field_type}\"\n    )]\n    DataConnectorDoesNotSupportNestedScalarArrayFiltering {\n        data_connector_name: Qualified<DataConnectorName>,\n        boolean_expression_type_name: Qualified<CustomTypeName>,\n        field_name: FieldName,\n        field_type: QualifiedTypeReference,\n    },\n    #[error(\n        \"the comparable field '{name}' is defined more than once in the boolean expression type '{type_name}'\"\n    )]\n    DuplicateComparableFieldFound {\n        type_name: Qualified<CustomTypeName>,\n        name: FieldName,\n    },\n    #[error(\n        \"the comparable relationship '{name}' is defined more than once in the boolean expression type '{type_name}'\"\n    )]","sourceCodeStart":17,"sourceCodeEnd":53,"githubUrl":"https://github.com/hasura/graphql-engine/blob/724551b9ae87845594ef0408cff0e50eb6c90dc5/v3/crates/metadata-resolve/src/stages/boolean_expressions/types.rs#L17-L53","documentation":"Emitted when a comparable field inside a boolean expression type is a scalar array and the data connector does not support filtering by nested scalar arrays.","triggerScenarios":"A boolean expression comparable field whose QualifiedTypeReference resolves to a scalar array type, with a data connector that lacks scalar-array filter support.","commonSituations":"Making a `[String]` or `[Int]` column comparable in a boolean expression against a connector that cannot filter arrays (e.g. non-SQL sources like REST or certain native connectors).","solutions":["Unmark the scalar array field as comparable","Model the array differently (JSON with supported operators, or a separate relationship) if filtering is needed","Switch to a connector that supports scalar array comparisons"],"exampleFix":"// before\ntags: [String]\n  comparable: true\n// after\ntags: [String]\n  comparable: false","handlingStrategy":"validation","validationCode":"for f in &be_type.comparable_fields {\n    if let QualifiedType::Array(inner) = &f.field_type.underlying {\n        if matches!(**inner, QualifiedType::Scalar(_)) && !connector.capabilities.scalar_array_filters {\n            return Err(format!(\"{} scalar array not filterable by {}\", f.name, connector.name));\n        }\n    }\n}","typeGuard":"fn is_scalar_array(t: &QualifiedTypeReference) -> bool {\n    matches!(t.underlying(), QualifiedType::Array(inner) if matches!(**inner, QualifiedType::Scalar(_)))\n}","tryCatchPattern":"if let BooleanExpressionIssue::DataConnectorDoesNotSupportNestedScalarArrayFiltering { field_name, data_connector_name, .. } = &issue {\n    log::warn!(\"{data_connector_name} cannot filter {field_name}\");\n}","preventionTips":["Confirm the connector supports array comparison operators","Avoid marking scalar arrays comparable for REST/limited connectors"],"tags":["rust","hasura","metadata","boolean-expressions","data-connector","arrays"],"backgroundTag":"unsupported-filter-type","analyzedSha":"724551b9ae87845594ef0408cff0e50eb6c90dc5","analyzedAt":"2026-08-28T07:32:55.105Z","schemaVersion":2},"datasetVersion":"2026-08-28T11:17:15.048Z"}