pytrilogy 0.0.2.8__tar.gz → 0.0.2.10__tar.gz

{pytrilogy-0.0.2.8/pytrilogy.egg-info → pytrilogy-0.0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrilogy
-Version: 0.0.2.8
+Version: 0.0.2.10
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.2.8 → pytrilogy-0.0.2.10/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrilogy
-Version: 0.0.2.8
+Version: 0.0.2.10
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.2.8 → pytrilogy-0.0.2.10}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.2.8"
+__version__ = "0.0.2.10"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.8 → pytrilogy-0.0.2.10}/trilogy/constants.py

@@ -24,6 +24,7 @@ class Optimizations:
     predicate_pushdown: bool = True
     datasource_inlining: bool = True
     constant_inlining: bool = True
+    constant_inline_cutoff: int = 3
     direct_return: bool = True
 
 

{pytrilogy-0.0.2.8 → pytrilogy-0.0.2.10}/trilogy/core/models.py

@@ -70,7 +70,7 @@ from trilogy.utility import unique
 from collections import UserList, UserDict
 from functools import cached_property
 from abc import ABC
-
+from collections import defaultdict
 
 LOGGER_PREFIX = "[MODELS]"
 
@@ -154,7 +154,10 @@ class ConceptArgs(ABC):
 class SelectContext(ABC):
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ):
         raise NotImplementedError
 
@@ -166,6 +169,7 @@ class ConstantInlineable(ABC):
 
 class SelectTypeMixin(BaseModel):
     where_clause: Union["WhereClause", None] = Field(default=None)
+    having_clause: Union["HavingClause", None] = Field(default=None)
 
     @property
     def output_components(self) -> List[Concept]:
@@ -595,13 +599,16 @@ class Concept(Mergeable, Namespaced, SelectContext, BaseModel):
         self,
         grain: Optional["Grain"] = None,
         conditional: Conditional | Comparison | Parenthetical | None = None,
+        environment: Environment | None = None,
     ) -> "Concept":
         if not all([isinstance(x, Concept) for x in self.keys or []]):
             raise ValueError(f"Invalid keys {self.keys} for concept {self.address}")
         new_grain = grain or self.grain
         new_lineage = self.lineage
         if isinstance(self.lineage, SelectContext):
-            new_lineage = self.lineage.with_select_context(new_grain, conditional)
+            new_lineage = self.lineage.with_select_context(
+                new_grain, conditional, environment=environment
+            )
         return self.__class__(
             name=self.name,
             datatype=self.datatype,
@@ -788,7 +795,9 @@ class Concept(Mergeable, Namespaced, SelectContext, BaseModel):
         return Granularity.MULTI_ROW
 
     def with_filter(
-        self, condition: "Conditional | Comparison | Parenthetical"
+        self,
+        condition: "Conditional | Comparison | Parenthetical",
+        environment: Environment | None = None,
     ) -> "Concept":
         from trilogy.utility import string_to_hash
 
@@ -805,12 +814,15 @@ class Concept(Mergeable, Namespaced, SelectContext, BaseModel):
             modifiers=self.modifiers,
             pseudonyms=self.pseudonyms,
         )
+        if environment:
+            environment.add_concept(new)
         return new
 
 
 class Grain(Mergeable, BaseModel):
     nested: bool = False
     components: List[Concept] = Field(default_factory=list, validate_default=True)
+    where_clause: Optional[WhereClause] = Field(default=None)
 
     @field_validator("components")
     def component_validator(cls, v, info: ValidationInfo):
@@ -836,10 +848,12 @@ class Grain(Mergeable, BaseModel):
 
     def __str__(self):
         if self.abstract:
-            return (
-                "Grain<Abstract" + ",".join([c.address for c in self.components]) + ">"
-            )
-        return "Grain<" + ",".join([c.address for c in self.components]) + ">"
+            base = "Grain<Abstract>"
+        else:
+            base = "Grain<" + ",".join([c.address for c in self.components]) + ">"
+        if self.where_clause:
+            base += f"|{str(self.where_clause)}"
+        return base
 
     def with_namespace(self, namespace: str) -> "Grain":
         return Grain(
@@ -1046,12 +1060,15 @@ class Function(Mergeable, Namespaced, SelectContext, BaseModel):
         return self.output_datatype
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> Function:
         if self.operator in FunctionClass.AGGREGATE_FUNCTIONS.value and conditional:
             base = [
                 (
-                    c.with_select_context(grain, conditional)
+                    c.with_select_context(grain, conditional, environment)
                     if isinstance(
                         c,
                         SelectContext,
@@ -1061,7 +1078,7 @@ class Function(Mergeable, Namespaced, SelectContext, BaseModel):
                 for c in self.arguments
             ]
             final = [
-                c.with_filter(conditional) if isinstance(c, Concept) else c
+                c.with_filter(conditional, environment) if isinstance(c, Concept) else c
                 for c in base
             ]
             return Function(
@@ -1077,7 +1094,7 @@ class Function(Mergeable, Namespaced, SelectContext, BaseModel):
             operator=self.operator,
             arguments=[
                 (
-                    c.with_select_context(grain, conditional)
+                    c.with_select_context(grain, conditional, environment)
                     if isinstance(
                         c,
                         SelectContext,
@@ -1293,13 +1310,22 @@ class WindowItem(Mergeable, Namespaced, SelectContext, BaseModel):
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> "WindowItem":
         return WindowItem(
             type=self.type,
-            content=self.content.with_select_context(grain, conditional),
-            over=[x.with_select_context(grain, conditional) for x in self.over],
-            order_by=[x.with_select_context(grain, conditional) for x in self.order_by],
+            content=self.content.with_select_context(grain, conditional, environment),
+            over=[
+                x.with_select_context(grain, conditional, environment)
+                for x in self.over
+            ],
+            order_by=[
+                x.with_select_context(grain, conditional, environment)
+                for x in self.order_by
+            ],
         )
 
     @property
@@ -1368,11 +1394,14 @@ class FilterItem(Namespaced, SelectContext, BaseModel):
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> FilterItem:
         return FilterItem(
-            content=self.content.with_select_context(grain, conditional),
-            where=self.where.with_select_context(grain, conditional),
+            content=self.content.with_select_context(grain, conditional, environment),
+            where=self.where.with_select_context(grain, conditional, environment),
         )
 
     @property
@@ -1452,9 +1481,17 @@ class OrderItem(Mergeable, SelectContext, Namespaced, BaseModel):
         return OrderItem(expr=self.expr.with_namespace(namespace), order=self.order)
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> "OrderItem":
-        return OrderItem(expr=self.expr.with_grain(grain), order=self.order)
+        return OrderItem(
+            expr=self.expr.with_select_context(
+                grain, conditional=conditional, environment=environment
+            ),
+            order=self.order,
+        )
 
     def with_merge(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
@@ -1643,7 +1680,9 @@ class SelectStatement(Mergeable, Namespaced, SelectTypeMixin, BaseModel):
                 )
             ):
                 output.append(item)
-        return Grain(components=unique(output, "address"))
+        return Grain(
+            components=unique(output, "address"), where_clause=self.where_clause
+        )
 
     def with_namespace(self, namespace: str) -> "SelectStatement":
         return SelectStatement(
@@ -1988,7 +2027,7 @@ class Datasource(Namespaced, BaseModel):
         return self.__repr__()
 
     def __hash__(self):
-        return (self.namespace + self.identifier).__hash__()
+        return self.full_name.__hash__()
 
     def with_namespace(self, namespace: str):
         new_namespace = (
@@ -2173,9 +2212,9 @@ class BaseJoin(BaseModel):
 class QueryDatasource(BaseModel):
     input_concepts: List[Concept]
     output_concepts: List[Concept]
+    datasources: List[Union[Datasource, "QueryDatasource"]]
     source_map: Dict[str, Set[Union[Datasource, "QueryDatasource", "UnnestJoin"]]]
 
-    datasources: List[Union[Datasource, "QueryDatasource"]]
     grain: Grain
     joins: List[BaseJoin | UnnestJoin]
     limit: Optional[int] = None
@@ -2227,19 +2266,16 @@ class QueryDatasource(BaseModel):
 
     @field_validator("source_map")
     @classmethod
-    def validate_source_map(cls, v, info: ValidationInfo):
+    def validate_source_map(cls, v: dict, info: ValidationInfo):
         values = info.data
-        expected = {c.address for c in values["output_concepts"]}.union(
-            c.address for c in values["input_concepts"]
-        )
-        seen = set()
-        for k, _ in v.items():
-            seen.add(k)
-        for x in expected:
-            if x not in seen and CONFIG.validate_missing:
-                raise SyntaxError(
-                    f"source map missing {x} on (expected {expected}, have {seen})"
-                )
+        for key in ("input_concepts", "output_concepts"):
+            if not values.get(key):
+                continue
+            for concept in values[key]:
+                if concept.address not in v and CONFIG.validate_missing:
+                    raise SyntaxError(
+                        f"Missing source map for {concept.address} on {key}, have {v}"
+                    )
         return v
 
     def __str__(self):
@@ -2308,11 +2344,23 @@ class QueryDatasource(BaseModel):
         )
 
         merged_datasources = {}
+
         for ds in [*self.datasources, *other.datasources]:
             if ds.full_name in merged_datasources:
                 merged_datasources[ds.full_name] = merged_datasources[ds.full_name] + ds
             else:
                 merged_datasources[ds.full_name] = ds
+
+        final_source_map = defaultdict(set)
+        for key in self.source_map:
+            final_source_map[key] = self.source_map[key].union(
+                other.source_map.get(key, set())
+            )
+        for key in other.source_map:
+            if key not in final_source_map:
+                final_source_map[key] = other.source_map[key]
+        for k, v in final_source_map.items():
+            final_source_map[k] = set(merged_datasources[x.full_name] for x in list(v))
         qds = QueryDatasource(
             input_concepts=unique(
                 self.input_concepts + other.input_concepts, "address"
@@ -2320,7 +2368,7 @@ class QueryDatasource(BaseModel):
             output_concepts=unique(
                 self.output_concepts + other.output_concepts, "address"
             ),
-            source_map={**self.source_map, **other.source_map},
+            source_map=final_source_map,
             datasources=list(merged_datasources.values()),
             grain=self.grain,
             joins=unique(self.joins + other.joins, "unique_id"),
@@ -2849,6 +2897,7 @@ class UndefinedConcept(Concept, Mergeable, Namespaced):
         self,
         grain: Optional["Grain"] = None,
         conditional: Conditional | Comparison | Parenthetical | None = None,
+        environment: Environment | None = None,
     ) -> "UndefinedConcept":
         if not all([isinstance(x, Concept) for x in self.keys or []]):
             raise ValueError(f"Invalid keys {self.keys} for concept {self.address}")
@@ -2856,7 +2905,9 @@ class UndefinedConcept(Concept, Mergeable, Namespaced):
         if self.lineage:
             new_lineage = self.lineage
             if isinstance(self.lineage, SelectContext):
-                new_lineage = self.lineage.with_select_context(new_grain, conditional)
+                new_lineage = self.lineage.with_select_context(
+                    new_grain, conditional, environment
+                )
         else:
             new_lineage = None
         return self.__class__(
@@ -3299,7 +3350,9 @@ class LazyEnvironment(Environment):
         ) or name.startswith("_"):
             return super().__getattribute__(name)
         if not self.loaded:
-            print(f"lazily evaluating load path {self.load_path} to access {name}")
+            logger.info(
+                f"lazily evaluating load path {self.load_path} to access {name}"
+            )
             from trilogy import parse
 
             env = Environment(working_path=str(self.working_path))
@@ -3441,16 +3494,23 @@ class Comparison(
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ):
         return self.__class__(
             left=(
-                self.left.with_select_context(grain, conditional)
+                self.left.with_select_context(grain, conditional, environment)
                 if isinstance(self.left, SelectContext)
                 else self.left
             ),
             # the right side does NOT need to inherit select grain
-            right=self.right,
+            right=(
+                self.right.with_select_context(grain, conditional, environment)
+                if isinstance(self.right, SelectContext)
+                else self.right
+            ),
             operator=self.operator,
         )
 
@@ -3534,12 +3594,15 @@ class SubselectComparison(Comparison):
         return [tuple(get_concept_arguments(self.right))]
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ):
-        # there's no need to pass the select grain through to a subselect comparison
+        # there's no need to pass the select grain through to a subselect comparison on the right
         return self.__class__(
             left=(
-                self.left.with_select_context(grain, conditional)
+                self.left.with_select_context(grain, conditional, environment)
                 if isinstance(self.left, SelectContext)
                 else self.left
             ),
@@ -3570,12 +3633,17 @@ class CaseWhen(Namespaced, SelectContext, BaseModel):
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> CaseWhen:
         return CaseWhen(
-            comparison=self.comparison.with_select_context(grain, conditional),
+            comparison=self.comparison.with_select_context(
+                grain, conditional, environment
+            ),
             expr=(
-                (self.expr.with_select_context(grain, conditional))
+                (self.expr.with_select_context(grain, conditional, environment))
                 if isinstance(self.expr, SelectContext)
                 else self.expr
             ),
@@ -3592,12 +3660,15 @@ class CaseElse(Namespaced, SelectContext, BaseModel):
         return get_concept_arguments(self.expr)
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> CaseElse:
         return CaseElse(
             discriminant=self.discriminant,
             expr=(
-                self.expr.with_select_context(grain, conditional)
+                self.expr.with_select_context(grain, conditional, environment)
                 if isinstance(
                     self.expr,
                     SelectContext,
@@ -3737,16 +3808,19 @@ class Conditional(
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ):
         return Conditional(
             left=(
-                self.left.with_select_context(grain, conditional)
+                self.left.with_select_context(grain, conditional, environment)
                 if isinstance(self.left, SelectContext)
                 else self.left
             ),
             right=(
-                self.right.with_select_context(grain, conditional)
+                self.right.with_select_context(grain, conditional, environment)
                 if isinstance(self.right, SelectContext)
                 else self.right
             ),
@@ -3855,13 +3929,16 @@ class AggregateWrapper(Mergeable, Namespaced, SelectContext, BaseModel):
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> AggregateWrapper:
         if not self.by:
             by = grain.components_copy
         else:
             by = self.by
-        parent = self.function.with_select_context(grain, conditional)
+        parent = self.function.with_select_context(grain, conditional, environment)
         return AggregateWrapper(function=parent, by=by)
 
 
@@ -3893,10 +3970,15 @@ class WhereClause(Mergeable, ConceptArgs, Namespaced, SelectContext, BaseModel):
         return WhereClause(conditional=self.conditional.with_namespace(namespace))
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ) -> WhereClause:
         return WhereClause(
-            conditional=self.conditional.with_select_context(grain, conditional)
+            conditional=self.conditional.with_select_context(
+                grain, conditional, environment
+            )
         )
 
     @property
@@ -3909,6 +3991,22 @@ class WhereClause(Mergeable, ConceptArgs, Namespaced, SelectContext, BaseModel):
                 output += item.grain.components if item.grain else []
         return Grain(components=list(set(output)))
 
+    @property
+    def components(self):
+        from trilogy.core.processing.utility import decompose_condition
+
+        return decompose_condition(self.conditional)
+
+    @property
+    def is_scalar(self):
+        from trilogy.core.processing.utility import is_scalar_condition
+
+        return is_scalar_condition(self.conditional)
+
+
+class HavingClause(WhereClause):
+    pass
+
 
 class MaterializedDataset(BaseModel):
     address: Address
@@ -3928,6 +4026,7 @@ class ProcessedQuery(BaseModel):
     hidden_columns: List[Concept] = Field(default_factory=list)
     limit: Optional[int] = None
     where_clause: Optional[WhereClause] = None
+    having_clause: Optional[HavingClause] = None
     order_by: Optional[OrderBy] = None
 
 
@@ -4130,11 +4229,14 @@ class Parenthetical(
         )
 
     def with_select_context(
-        self, grain: Grain, conditional: Conditional | Comparison | Parenthetical | None
+        self,
+        grain: Grain,
+        conditional: Conditional | Comparison | Parenthetical | None,
+        environment: Environment | None = None,
     ):
         return Parenthetical(
             content=(
-                self.content.with_select_context(grain, conditional)
+                self.content.with_select_context(grain, conditional, environment)
                 if isinstance(self.content, SelectContext)
                 else self.content
             )

{pytrilogy-0.0.2.8 → pytrilogy-0.0.2.10}/trilogy/core/optimization.py

@@ -17,19 +17,58 @@ from trilogy.core.optimizations import (
 MAX_OPTIMIZATION_LOOPS = 100
 
 
+# other optimizations may make a CTE a pure passthrough
+# remove those
+# def is_locally_irrelevant(cte: CTE) -> CTE | bool:
+#     if not len(cte.parent_ctes) == 1:
+#         return False
+#     parent = cte.parent_ctes[0]
+#     if not parent.output_columns == cte.output_columns:
+#         return False
+#     if cte.condition is not None:
+#         return False
+#     if cte.group_to_grain:
+#         return False
+#     if len(cte.joins)>1:
+#         return False
+#     return parent
+
+
 def filter_irrelevant_ctes(
     input: list[CTE],
     root_cte: CTE,
 ):
     relevant_ctes = set()
 
-    def recurse(cte: CTE):
+    def recurse(cte: CTE, inverse_map: dict[str, list[CTE]]):
+        # TODO: revisit this
+        # if parent := is_locally_irrelevant(cte):
+        #     logger.info(
+        #         f"[Optimization][Irrelevent CTE filtering] Removing redundant CTE {cte.name} and replacing with {parent.name}"
+        #     )
+        #     for child in inverse_map.get(cte.name, []):
+        #         child.parent_ctes = [
+        #             x for x in child.parent_ctes if x.name != cte.name
+        #         ] + [parent]
+        #         for x in child.source_map:
+        #             if cte.name in child.source_map[x]:
+        #                 child.source_map[x].remove(cte.name)
+        #                 child.source_map[x].append(parent.name)
+        #         for x2 in child.existence_source_map:
+        #             if cte.name in child.existence_source_map[x2]:
+        #                 child.existence_source_map[x2].remove(cte.name)
+        #                 child.existence_source_map[x2].append(parent.name)
+        # else:
         relevant_ctes.add(cte.name)
         for cte in cte.parent_ctes:
-            recurse(cte)
-
-    recurse(root_cte)
-    return [cte for cte in input if cte.name in relevant_ctes]
+            recurse(cte, inverse_map)
+
+    inverse_map = gen_inverse_map(input)
+    recurse(root_cte, inverse_map)
+    final = [cte for cte in input if cte.name in relevant_ctes]
+    if len(final) == len(input):
+        return input
+    return filter_irrelevant_ctes(final, root_cte)
 
 
 def gen_inverse_map(input: list[CTE]) -> dict[str, list[CTE]]:

{pytrilogy-0.0.2.8 → pytrilogy-0.0.2.10}/trilogy/core/optimizations/inline_datasource.py

@@ -5,6 +5,7 @@ from trilogy.core.models import (
 
 from trilogy.core.optimizations.base_optimization import OptimizationRule
 from collections import defaultdict
+from trilogy.constants import CONFIG
 
 
 class InlineDatasource(OptimizationRule):
@@ -18,28 +19,28 @@ class InlineDatasource(OptimizationRule):
         if not cte.parent_ctes:
             return False
 
-        self.log(
+        self.debug(
             f"Checking {cte.name} for consolidating inline tables with {len(cte.parent_ctes)} parents"
         )
         to_inline: list[CTE] = []
         force_group = False
         for parent_cte in cte.parent_ctes:
             if not parent_cte.is_root_datasource:
-                self.log(f"parent {parent_cte.name} is not root")
+                self.debug(f"parent {parent_cte.name} is not root")
                 continue
             if parent_cte.parent_ctes:
-                self.log(f"parent {parent_cte.name} has parents")
+                self.debug(f"parent {parent_cte.name} has parents")
                 continue
             if parent_cte.condition:
-                self.log(f"parent {parent_cte.name} has condition, cannot be inlined")
+                self.debug(f"parent {parent_cte.name} has condition, cannot be inlined")
                 continue
             raw_root = parent_cte.source.datasources[0]
             if not isinstance(raw_root, Datasource):
-                self.log(f"parent {parent_cte.name} is not datasource")
+                self.debug(f"Parent {parent_cte.name} is not datasource")
                 continue
             root: Datasource = raw_root
             if not root.can_be_inlined:
-                self.log(f"parent {parent_cte.name} datasource is not inlineable")
+                self.debug(f"Parent {parent_cte.name} datasource is not inlineable")
                 continue
             root_outputs = {x.address for x in root.output_concepts}
             inherited = {
@@ -52,7 +53,9 @@ class InlineDatasource(OptimizationRule):
                 )
                 continue
             if not root.grain.issubset(parent_cte.grain):
-                self.log(f"Not all {parent_cte.name} is at wrong grain to inline")
+                self.log(
+                    f"{parent_cte.name} is at wrong grain to inline ({root.grain} vs {parent_cte.grain})"
+                )
                 continue
             to_inline.append(parent_cte)
 
@@ -62,7 +65,10 @@ class InlineDatasource(OptimizationRule):
                 self.candidates[cte.name].add(replaceable.name)
                 self.count[replaceable.source.name] += 1
                 return True
-            if self.count[replaceable.source.name] > 1:
+            if (
+                self.count[replaceable.source.name]
+                > CONFIG.optimizations.constant_inline_cutoff
+            ):
                 self.log(
                     f"Skipping inlining raw datasource {replaceable.source.name} ({replaceable.name}) due to multiple references"
                 )