feat(tesseract): apply view default value filters in QueryPropertiesCompiler

Default-value filters declared on a view (CORE-357) are now materialized
into the query during `QueryPropertiesCompiler::compile_filters`:

- Active views are detected from compiled MemberSymbols
  (`compiled_path().cube_name()` for every dimension / time-dim / measure
  / filter-member). Each view's `filters()` becomes a candidate.
- A candidate is dispatched through the existing `FilterCompiler::add_item`
  so default filters share the same operator/typing path as explicit ones,
  and get routed into the right bucket (dimension / measure / time-dim).
- `unless` is filter-only: a member referenced only by projection does not
  release the default, since changing what columns the user selects must
  not silently change the row set. Only an explicit filter on the same
  member overrides the default.

JS evaluator (CubeEvaluator.prepareViewFilters) resolves `member` / `unless`
to view-scoped paths (`<view>.<member>`) so they line up with
`MemberSymbol::full_name` on the Rust side.

Test coverage:

- Unit (cube_evaluator-level): default filter applies when view is active;
  projection alone does not trigger `unless`; explicit filter on the
  unless-member releases the default; filter applies when unless-member is
  absent; filter applies even when member is in dimensions if `unless` is
  not declared.
- Postgres integration: virtual `type: switch` currency dim plus a
  `case`-switch measure on `country`; covers union-collapse via default
  filter, projection-not-triggering-unless, explicit-filter-overrides,
  default-filter-with-switch-measure, default-filter-when-unless-member-
  is-absent.

The Postgres seed (`view_default_filters_tables.sql`) deliberately ships
without a `currency` column — currency is purely virtual; `country` drives
the switch-case measure.

Author: waralexrom

packages/cubejs-schema-compiler/src/compiler/CubeEvaluator.ts

@@ -221,17 +221,18 @@ export class CubeEvaluator extends CubeSymbols {
 
     const included = (cube.includedMembers as ViewIncludedMember[] | undefined) || [];
 
+    // Always returns view-scoped path `<view>.<member>` to match
+    // MemberSymbol::full_name on the Rust side, which is what `unless` and
+    // filter dispatch compare against.
     const resolveViewMember = (memberType: string, reference: string): string | null => {
       let lookupName = reference;
       let lookupPath: string | null = null;
 
       if (reference.indexOf('.') !== -1) {
         const parts = reference.split('.');
         if (parts[0] === cube.name) {
-          // Identifier form resolved via view's own namespace, e.g. 'orders_view.currency'
           lookupName = parts.slice(1).join('.');
         } else {
-          // Fully-qualified member path, e.g. 'orders.currency'
           lookupPath = reference;
         }
       }
@@ -246,7 +247,7 @@ export class CubeEvaluator extends CubeSymbols {
         );
         return null;
       }
-      return match.memberPath;
+      return `${cube.name}.${match.name}`;
     };
 
     for (const filter of cube.filters as ViewDefaultValueFilter[]) {

packages/cubejs-schema-compiler/test/unit/schema.test.ts

@@ -575,17 +575,17 @@ describe('Schema Testing', () => {
       expect(filters).toHaveLength(3);
 
       expect(filters[0].operator).toBe('equals');
-      expect(filters[0].memberReference).toBe('orders.currency');
+      expect(filters[0].memberReference).toBe('orders_view.currency');
       expect(filters[0].valuesReferences).toEqual(['USD']);
-      expect(filters[0].unlessReferences).toEqual(['orders.currency', 'orders.country']);
+      expect(filters[0].unlessReferences).toEqual(['orders_view.currency', 'orders_view.country']);
 
       expect(filters[1].operator).toBe('set');
-      expect(filters[1].memberReference).toBe('orders.country');
+      expect(filters[1].memberReference).toBe('orders_view.country');
       expect(filters[1].valuesReferences).toBeUndefined();
       expect(filters[1].unlessReferences).toBeUndefined();
 
       expect(filters[2].operator).toBe('in');
-      expect(filters[2].memberReference).toBe('orders.id');
+      expect(filters[2].memberReference).toBe('orders_view.id');
       // Values are coerced to strings to match the FilterItem contract used
       // by regular query filters on the Rust side.
       expect(filters[2].valuesReferences).toEqual(['1', '2', 'true', 'draft', null]);
@@ -619,9 +619,9 @@ describe('Schema Testing', () => {
 
       const filters = cubeEvaluator.evaluatedCubes.orders_view.filters!;
       expect(filters.map(f => f.memberReference)).toEqual([
-        'orders.currency',
-        'orders.currency',
-        'orders.currency',
+        'orders_view.currency',
+        'orders_view.currency',
+        'orders_view.currency',
       ]);
     });
 

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs

@@ -62,6 +62,14 @@ impl<'a> FilterCompiler<'a> {
         )
     }
 
+    /// Iterator over every compiled filter item across the three buckets.
+    pub fn iter_all_items(&self) -> impl Iterator<Item = &FilterItem> {
+        self.dimension_filters
+            .iter()
+            .chain(self.time_dimension_filters.iter())
+            .chain(self.measures_filters.iter())
+    }
+
     fn compile_item(
         &mut self,
         item: &NativeFilterItem,

rust/cube/cubesqlplanner/cubesqlplanner/src/planner/query_properties_compiler.rs

@@ -2,16 +2,18 @@
 //! resolves member/segment/filter/order references against the cube
 //! evaluator and folds them into the typed builder.
 
+use std::collections::HashSet;
 use std::rc::Rc;
 
 use cubenativeutils::CubeError;
 use itertools::Itertools;
 
-use crate::cube_bridge::base_query_options::BaseQueryOptions;
+use crate::cube_bridge::base_query_options::{BaseQueryOptions, FilterItem as NativeFilterItem};
 use crate::cube_bridge::member_expression::{
     MemberExpressionDefinition, MemberExpressionExpressionDef,
 };
 use crate::cube_bridge::options_member::OptionsMember;
+use crate::cube_bridge::view_filter_definition::ViewFilterDefinition;
 
 use super::filter::compiler::FilterCompiler;
 use super::filter::{BaseSegment, FilterItem};
@@ -47,8 +49,14 @@ impl QueryPropertiesCompiler {
         let measures = self.compile_measures(&mut evaluator_compiler, options)?;
         let segments = self.compile_segments(&mut evaluator_compiler, options)?;
 
-        let (dimensions_filters, time_dimensions_filters, measures_filters) =
-            self.compile_filters(&mut evaluator_compiler, options, &time_dimensions_raw)?;
+        let (dimensions_filters, time_dimensions_filters, measures_filters) = self
+            .compile_filters(
+                &mut evaluator_compiler,
+                options,
+                &dimensions,
+                &time_dimensions_raw,
+                &measures,
+            )?;
 
         // FIXME may be this filter should be applied on other place
         let time_dimensions = Self::filter_time_dimensions_with_granularity(time_dimensions_raw);
@@ -371,13 +379,17 @@ impl QueryPropertiesCompiler {
     }
 
     // Returns `(dimension_filters, time_dimension_filters, measure_filters)`.
-    // Includes both the explicit `options.filters` entries and the implicit
-    // `dateRange` filter carried by each time dimension.
+    // Includes:
+    //   - explicit `options.filters` entries,
+    //   - the implicit `dateRange` filter carried by each time dimension,
+    //   - default-value filters declared on any view active in the query.
     fn compile_filters(
         &self,
         evaluator_compiler: &mut Compiler,
         options: &dyn BaseQueryOptions,
+        dimensions: &[Rc<MemberSymbol>],
         time_dimensions: &[Rc<MemberSymbol>],
+        measures: &[Rc<MemberSymbol>],
     ) -> Result<(Vec<FilterItem>, Vec<FilterItem>, Vec<FilterItem>), CubeError> {
         let mut filter_compiler = FilterCompiler::new(evaluator_compiler, self.query_tools.clone());
         if let Some(filters) = &options.static_data().filters {
@@ -388,9 +400,98 @@ impl QueryPropertiesCompiler {
         for time_dimension in time_dimensions {
             filter_compiler.add_time_dimension_item(time_dimension)?;
         }
+        self.apply_view_default_filters(
+            &mut filter_compiler,
+            dimensions,
+            time_dimensions,
+            measures,
+        )?;
         Ok(filter_compiler.extract_result())
     }
 
+    // Adds default-value filters declared on any view that the query touches.
+    //
+    // A view is "active" when any compiled member of the query (a dimension,
+    // time dimension, measure, or member referenced by an explicit filter)
+    // is owned by a cube with `is_view == true`. We read this directly off
+    // each `MemberSymbol::compiled_path().cube_name()` — no second pass over
+    // the raw `options` string paths.
+    //
+    // A default filter is applied unless `unless_references` is provided
+    // and at least one of those member paths is mentioned in the query —
+    // "mentioned" being the full_name of any compiled member symbol.
+    fn apply_view_default_filters(
+        &self,
+        filter_compiler: &mut FilterCompiler,
+        dimensions: &[Rc<MemberSymbol>],
+        time_dimensions: &[Rc<MemberSymbol>],
+        measures: &[Rc<MemberSymbol>],
+    ) -> Result<(), CubeError> {
+        // Filter members are materialized once — we can't keep an immutable
+        // borrow on `filter_compiler` while later calling `add_item` (mutable
+        // borrow) on it inside the apply loop below.
+        let filter_members: Vec<Rc<MemberSymbol>> = filter_compiler
+            .iter_all_items()
+            .flat_map(|f| f.all_member_evaluators())
+            .collect();
+
+        // `unless` is intentionally filter-only: adding a member to the
+        // projection (dimension / measure / time dimension) should never
+        // silently change the row set, so a projection alone is not enough
+        // to drop the default filter. Only an explicit filter on the member
+        // counts as an "override" and releases the guard.
+        let mentioned_in_filters: HashSet<String> =
+            filter_members.iter().map(|s| s.full_name()).collect();
+
+        // View activation, by contrast, looks at every compiled member: if
+        // the query touches a view in any way (projection or filter), its
+        // default filters become candidates. De-duplicated by view name so
+        // each view is inspected at most once.
+        let cube_evaluator = self.query_tools.cube_evaluator();
+        let mut visited_cubes: HashSet<String> = HashSet::new();
+        let mut pending_view_filters: Vec<Rc<dyn ViewFilterDefinition>> = Vec::new();
+
+        for sym in dimensions
+            .iter()
+            .chain(time_dimensions)
+            .chain(measures)
+            .chain(filter_members.iter())
+        {
+            let cube_name = sym.compiled_path().cube_name();
+            if !visited_cubes.insert(cube_name.clone()) {
+                continue;
+            }
+            let cube_def = cube_evaluator.cube_from_path(cube_name.clone())?;
+            if !cube_def.static_data().is_view.unwrap_or(false) {
+                continue;
+            }
+            if let Some(view_filters) = cube_def.filters()? {
+                pending_view_filters.extend(view_filters);
+            }
+        }
+
+        for vf in pending_view_filters {
+            let s = vf.static_data();
+            let should_apply = match &s.unless_references {
+                None => true,
+                Some(refs) => !refs.iter().any(|r| mentioned_in_filters.contains(r)),
+            };
+            if !should_apply {
+                continue;
+            }
+            let native_filter = NativeFilterItem {
+                or: None,
+                and: None,
+                member: Some(s.member_reference.clone()),
+                dimension: None,
+                operator: Some(s.operator.clone()),
+                values: s.values_references.clone(),
+            };
+            filter_compiler.add_item(&native_filter)?;
+        }
+        Ok(())
+    }
+
     // Drop time-dimension symbols that have no granularity. Non-time-
     // dimension symbols pass through unchanged.
     fn filter_time_dimensions_with_granularity(

rust/cube/cubesqlplanner/cubesqlplanner/src/test_fixtures/cube_bridge/mock_schema.rs

@@ -2,7 +2,7 @@ use crate::test_fixtures::cube_bridge::yaml::YamlSchema;
 use crate::test_fixtures::cube_bridge::{
     MockBaseTools, MockCubeDefinition, MockCubeEvaluator, MockDimensionDefinition, MockDriverTools,
     MockGranularityDefinition, MockJoinGraph, MockJoinItemDefinition, MockMeasureDefinition,
-    MockPreAggregationDescription, MockSegmentDefinition,
+    MockPreAggregationDescription, MockSegmentDefinition, MockViewFilterDefinition,
 };
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
@@ -340,6 +340,7 @@ impl MockSchemaBuilder {
             measures: HashMap::new(),
             dimensions: HashMap::new(),
             segments: HashMap::new(),
+            default_filters: Vec::new(),
         }
     }
 
@@ -468,6 +469,7 @@ pub struct MockViewBuilder {
     measures: HashMap<String, Rc<MockMeasureDefinition>>,
     dimensions: HashMap<String, Rc<MockDimensionDefinition>>,
     segments: HashMap<String, Rc<MockSegmentDefinition>>,
+    default_filters: Vec<MockViewFilterDefinition>,
 }
 
 impl MockViewBuilder {
@@ -522,6 +524,11 @@ impl MockViewBuilder {
         self
     }
 
+    pub fn add_default_filter(mut self, filter: MockViewFilterDefinition) -> Self {
+        self.default_filters.push(filter);
+        self
+    }
+
     pub fn finish_view(mut self) -> MockSchemaBuilder {
         let mut all_dimensions = self.dimensions;
         let mut all_measures = self.measures;
@@ -634,6 +641,7 @@ impl MockViewBuilder {
         let view_def = MockCubeDefinition::builder()
             .name(self.view_name.clone())
             .is_view(Some(true))
+            .filters(self.default_filters)
             .build();
 
         let view_cube = MockCube {

rust/cube/cubesqlplanner/cubesqlplanner/src/test_fixtures/cube_bridge/yaml/schema.rs

@@ -4,6 +4,7 @@ use crate::test_fixtures::cube_bridge::yaml::{
 };
 use crate::test_fixtures::cube_bridge::{
     MockCubeDefinition, MockJoinItemDefinition, MockSchema, MockSchemaBuilder,
+    MockViewFilterDefinition,
 };
 use cubenativeutils::CubeError;
 use serde::Deserialize;
@@ -77,6 +78,21 @@ struct YamlPreAggregationEntry {
 struct YamlView {
     name: String,
     cubes: Vec<YamlViewCube>,
+    #[serde(default)]
+    filters: Vec<YamlViewFilter>,
+}
+
+#[derive(Debug, Deserialize)]
+struct YamlViewFilter {
+    // Member references must be supplied in the view's own namespace
+    // (`<view>.<member>`); the YAML harness does not duplicate the JS
+    // evaluator's resolution logic.
+    member: String,
+    operator: String,
+    #[serde(default)]
+    values: Option<Vec<Option<String>>>,
+    #[serde(default)]
+    unless: Option<Vec<String>>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -172,6 +188,18 @@ impl YamlSchema {
                     view_builder.include_cube_with_prefix(view_cube.join_path, includes, prefix);
             }
 
+            for filter in view.filters {
+                // TypedBuilder uses a type-state chain, so set both optional
+                // legs in a single expression even when one of them is None.
+                let mock_filter = MockViewFilterDefinition::builder()
+                    .operator(filter.operator)
+                    .member_reference(filter.member)
+                    .values_references(filter.values)
+                    .unless_references(filter.unless)
+                    .build();
+                view_builder = view_builder.add_default_filter(mock_filter);
+            }
+
             builder = view_builder.finish_view();
         }