pytrilogy 0.0.1.105__tar.gz → 0.0.1.107__tar.gz

{pytrilogy-0.0.1.105/pytrilogy.egg-info → pytrilogy-0.0.1.107}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrilogy
-Version: 0.0.1.105
+Version: 0.0.1.107
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -275,3 +275,81 @@ but all are worth checking out. Please open PRs/comment for anything missed!
 - [malloy](https://github.com/malloydata/malloy)
 - [preql](https://github.com/erezsh/Preql)
 - [PREQL](https://github.com/PRQL/prql)
+
+## Minimal Syntax Reference
+
+#### IMPORT
+
+`import <path> as <alias>;`
+
+#### CONCEPT
+
+Types: `string | int | float | bool | date | datetime | time | timestamp | interval`;
+
+Key:
+`key <name> <type>;`
+
+Property:
+`property <key>.<name> <type>;`
+
+Transformation:
+`auto <name> <- <expression>;`
+
+#### DATASOURCE
+```sql
+datasource <name>(
+    <column>:<concept>,
+    <column>:<concept>,
+)
+grain(<concept>, <concept>)
+address <table>;
+```
+
+#### SELECT
+
+Primary acces
+
+```sql
+select
+    <concept>,
+    <concept>+1 -> <alias>
+WHERE
+    <concept> = <value>
+ORDER BY
+    <concept> asc|desc
+;
+```
+
+#### CTE/ROWSET
+
+Reusable virtual set of rows. Useful for windows, filtering. 
+
+```sql
+with <alias> as
+select
+    <concept>,
+    <concept>+1 -> <alias>
+WHERE
+    <concept> = <value>
+
+select <alias>.<concept>;
+
+```
+
+
+#### PERSIST
+
+Store output of a query in a warehouse table
+
+```sql
+persist <alias> as <table_name> from
+<select>;
+```
+
+#### SHOW
+
+Return generated SQL without executing.
+
+```sql
+show <select>;
+```

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107}/README.md

@@ -246,3 +246,81 @@ but all are worth checking out. Please open PRs/comment for anything missed!
 - [malloy](https://github.com/malloydata/malloy)
 - [preql](https://github.com/erezsh/Preql)
 - [PREQL](https://github.com/PRQL/prql)
+
+## Minimal Syntax Reference
+
+#### IMPORT
+
+`import <path> as <alias>;`
+
+#### CONCEPT
+
+Types: `string | int | float | bool | date | datetime | time | timestamp | interval`;
+
+Key:
+`key <name> <type>;`
+
+Property:
+`property <key>.<name> <type>;`
+
+Transformation:
+`auto <name> <- <expression>;`
+
+#### DATASOURCE
+```sql
+datasource <name>(
+    <column>:<concept>,
+    <column>:<concept>,
+)
+grain(<concept>, <concept>)
+address <table>;
+```
+
+#### SELECT
+
+Primary acces
+
+```sql
+select
+    <concept>,
+    <concept>+1 -> <alias>
+WHERE
+    <concept> = <value>
+ORDER BY
+    <concept> asc|desc
+;
+```
+
+#### CTE/ROWSET
+
+Reusable virtual set of rows. Useful for windows, filtering. 
+
+```sql
+with <alias> as
+select
+    <concept>,
+    <concept>+1 -> <alias>
+WHERE
+    <concept> = <value>
+
+select <alias>.<concept>;
+
+```
+
+
+#### PERSIST
+
+Store output of a query in a warehouse table
+
+```sql
+persist <alias> as <table_name> from
+<select>;
+```
+
+#### SHOW
+
+Return generated SQL without executing.
+
+```sql
+show <select>;
+```

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytrilogy
-Version: 0.0.1.105
+Version: 0.0.1.107
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -275,3 +275,81 @@ but all are worth checking out. Please open PRs/comment for anything missed!
 - [malloy](https://github.com/malloydata/malloy)
 - [preql](https://github.com/erezsh/Preql)
 - [PREQL](https://github.com/PRQL/prql)
+
+## Minimal Syntax Reference
+
+#### IMPORT
+
+`import <path> as <alias>;`
+
+#### CONCEPT
+
+Types: `string | int | float | bool | date | datetime | time | timestamp | interval`;
+
+Key:
+`key <name> <type>;`
+
+Property:
+`property <key>.<name> <type>;`
+
+Transformation:
+`auto <name> <- <expression>;`
+
+#### DATASOURCE
+```sql
+datasource <name>(
+    <column>:<concept>,
+    <column>:<concept>,
+)
+grain(<concept>, <concept>)
+address <table>;
+```
+
+#### SELECT
+
+Primary acces
+
+```sql
+select
+    <concept>,
+    <concept>+1 -> <alias>
+WHERE
+    <concept> = <value>
+ORDER BY
+    <concept> asc|desc
+;
+```
+
+#### CTE/ROWSET
+
+Reusable virtual set of rows. Useful for windows, filtering. 
+
+```sql
+with <alias> as
+select
+    <concept>,
+    <concept>+1 -> <alias>
+WHERE
+    <concept> = <value>
+
+select <alias>.<concept>;
+
+```
+
+
+#### PERSIST
+
+Store output of a query in a warehouse table
+
+```sql
+persist <alias> as <table_name> from
+<select>;
+```
+
+#### SHOW
+
+Return generated SQL without executing.
+
+```sql
+show <select>;
+```

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107}/pytrilogy.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ trilogy/core/functions.py
 trilogy/core/graph_models.py
 trilogy/core/internal.py
 trilogy/core/models.py
+trilogy/core/optimization.py
 trilogy/core/query_processor.py
 trilogy/core/processing/__init__.py
 trilogy/core/processing/concept_strategies_v3.py

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107}/tests/test_select.py

@@ -125,4 +125,5 @@ def test_modifiers():
     generator = BigqueryDialect()
 
     text = generator.compile_statement(query)
-    assert "`b` = 2" in text
+    assert "2 = 2" in text
+    assert "as `b`" not in text

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107}/trilogy/__init__.py

@@ -2,7 +2,8 @@ from trilogy.core.models import Environment
 from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
+from trilogy.constants import CONFIG
 
-__version__ = "0.0.1.105"
+__version__ = "0.0.1.107"
 
-__all__ = ["parse", "Executor", "Dialects", "Environment"]
+__all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107}/trilogy/constants.py

@@ -23,6 +23,7 @@ NULL_VALUE = MagicConstants.NULL
 class Config:
     strict_mode: bool = True
     human_identifiers: bool = True
+    inline_datasources: bool = True
 
 
 CONFIG = Config()

{pytrilogy-0.0.1.105 → pytrilogy-0.0.1.107}/trilogy/core/models.py

@@ -34,7 +34,11 @@ from pydantic import (
 from lark.tree import Meta
 from pathlib import Path
 from trilogy.constants import logger, DEFAULT_NAMESPACE, ENV_CACHE_NAME, MagicConstants
-from trilogy.core.constants import ALL_ROWS_CONCEPT, INTERNAL_NAMESPACE
+from trilogy.core.constants import (
+    ALL_ROWS_CONCEPT,
+    INTERNAL_NAMESPACE,
+    CONSTANT_DATASET,
+)
 from trilogy.core.enums import (
     InfiniteFunctionArgs,
     Purpose,
@@ -1434,6 +1438,7 @@ class MultiSelectStatement(Namespaced, BaseModel):
 
 class Address(BaseModel):
     location: str
+    is_query: bool = False
 
 
 class Query(BaseModel):
@@ -1529,10 +1534,27 @@ class Datasource(Namespaced, BaseModel):
         default_factory=lambda: DatasourceMetadata(freshness_concept=None)
     )
 
+    @property
+    def condition(self):
+        return None
+
     @cached_property
     def output_lcl(self) -> LooseConceptList:
         return LooseConceptList(concepts=self.output_concepts)
 
+    @property
+    def can_be_inlined(self) -> bool:
+        if isinstance(self.address, Address) and self.address.is_query:
+            return False
+        for x in self.columns:
+            if not isinstance(x.alias, str):
+                return False
+        return True
+
+    @property
+    def non_partial_concept_addresses(self) -> set[str]:
+        return set([c.address for c in self.full_concepts])
+
     @field_validator("namespace", mode="plain")
     @classmethod
     def namespace_validation(cls, v):
@@ -1647,7 +1669,7 @@ class Datasource(Namespaced, BaseModel):
         namespace = self.namespace.replace(".", "_") if self.namespace else ""
         return f"{namespace}_{self.identifier}"
 
-    @cached_property
+    @property
     def safe_location(self) -> str:
         if isinstance(self.address, Address):
             return self.address.location
@@ -1746,7 +1768,7 @@ class QueryDatasource(BaseModel):
     input_concepts: List[Concept]
     output_concepts: List[Concept]
     source_map: Dict[str, Set[Union[Datasource, "QueryDatasource", "UnnestJoin"]]]
-    datasources: Sequence[Union[Datasource, "QueryDatasource"]]
+    datasources: List[Union[Datasource, "QueryDatasource"]]
     grain: Grain
     joins: List[BaseJoin | UnnestJoin]
     limit: Optional[int] = None
@@ -1797,10 +1819,7 @@ class QueryDatasource(BaseModel):
             c.address for c in values["input_concepts"]
         )
         seen = set()
-        for k, val in v.items():
-            # if val:
-            #     if len(val) != 1:
-            #         raise SyntaxError(f"source map {k} has multiple values {len(val)}")
+        for k, _ in v.items():
             seen.add(k)
         for x in expected:
             if x not in seen:
@@ -1922,18 +1941,18 @@ class QueryDatasource(BaseModel):
         )
 
     def get_alias(
-        self, concept: Concept, use_raw_name: bool = False, force_alias: bool = False
+        self,
+        concept: Concept,
+        use_raw_name: bool = False,
+        force_alias: bool = False,
+        source: str | None = None,
     ):
-        # if we should use the raw datasource name to access
-        use_raw_name = (
-            True
-            if (len(self.datasources) == 1 or use_raw_name) and not force_alias
-            # if ((len(self.datasources) == 1 and isinstance(self.datasources[0], Datasource)) or use_raw_name) and not force_alias
-            else False
-        )
         for x in self.datasources:
             # query datasources should be referenced by their alias, always
             force_alias = isinstance(x, QueryDatasource)
+            use_raw_name = isinstance(x, Datasource) and not force_alias
+            if source and x.identifier != source:
+                continue
             try:
                 return x.get_alias(
                     concept.with_grain(self.grain),
@@ -1967,8 +1986,7 @@ class Comment(BaseModel):
 
 class CTE(BaseModel):
     name: str
-    source: "QueryDatasource"  # TODO: make recursive
-    # output columns are what are selected/grouped by
+    source: "QueryDatasource"
     output_columns: List[Concept]
     source_map: Dict[str, str | list[str]]
     grain: Grain
@@ -1979,6 +1997,10 @@ class CTE(BaseModel):
     condition: Optional[Union["Conditional", "Comparison", "Parenthetical"]] = None
     partial_concepts: List[Concept] = Field(default_factory=list)
     join_derived_concepts: List[Concept] = Field(default_factory=list)
+    order_by: Optional[OrderBy] = None
+    limit: Optional[int] = None
+    requires_nesting: bool = True
+    base_name_override: Optional[str] = None
 
     @computed_field  # type: ignore
     @property
@@ -1989,6 +2011,40 @@ class CTE(BaseModel):
     def validate_output_columns(cls, v):
         return unique(v, "address")
 
+    def inline_parent_datasource(self, parent: CTE) -> bool:
+        qds_being_inlined = parent.source
+        ds_being_inlined = qds_being_inlined.datasources[0]
+        if not isinstance(ds_being_inlined, Datasource):
+            return False
+        self.source.datasources = [
+            ds_being_inlined,
+            *[
+                x
+                for x in self.source.datasources
+                if x.identifier != qds_being_inlined.identifier
+            ],
+        ]
+        # need to identify this before updating joins
+        if self.base_name == parent.name:
+            self.base_name_override = ds_being_inlined.safe_location
+
+        for join in self.joins:
+            if isinstance(join, InstantiatedUnnestJoin):
+                continue
+            if join.left_cte.name == parent.name:
+                join.left_cte = ds_being_inlined
+            if join.right_cte.name == parent.name:
+                join.right_cte = ds_being_inlined
+        for k, v in self.source_map.items():
+            if isinstance(v, list):
+                self.source_map[k] = [
+                    ds_being_inlined.name if x == parent.name else x for x in v
+                ]
+            elif v == parent.name:
+                self.source_map[k] = ds_being_inlined.name
+        self.parent_ctes = [x for x in self.parent_ctes if x.name != parent.name]
+        return True
+
     def __add__(self, other: "CTE"):
         logger.info('Merging two copies of CTE "%s"', self.name)
         if not self.grain == other.grain:
@@ -2031,16 +2087,25 @@ class CTE(BaseModel):
     def relevant_base_ctes(self):
         return self.parent_ctes
 
+    @property
+    def is_root_datasource(self) -> bool:
+        return (
+            len(self.source.datasources) == 1
+            and isinstance(self.source.datasources[0], Datasource)
+            and not self.source.datasources[0].name == CONSTANT_DATASET
+        )
+
     @property
     def base_name(self) -> str:
+        if self.base_name_override:
+            return self.base_name_override
         # if this cte selects from a single datasource, select right from it
         valid_joins: List[Join] = [
             join for join in self.joins if isinstance(join, Join)
         ]
-        if len(self.source.datasources) == 1 and isinstance(
-            self.source.datasources[0], Datasource
-        ):
+        if self.is_root_datasource:
             return self.source.datasources[0].safe_location
+
         # if we have multiple joined CTEs, pick the base
         # as the root
         elif len(self.source.datasources) == 1 and len(self.parent_ctes) == 1:
@@ -2066,11 +2131,10 @@ class CTE(BaseModel):
 
     @property
     def base_alias(self) -> str:
+
+        if self.is_root_datasource:
+            return self.source.datasources[0].identifier
         relevant_joins = [j for j in self.joins if isinstance(j, Join)]
-        if len(self.source.datasources) == 1 and isinstance(
-            self.source.datasources[0], Datasource
-        ):
-            return self.source.datasources[0].full_name.replace(".", "_")
         if relevant_joins:
             return relevant_joins[0].left_cte.name
         elif self.relevant_base_ctes:
@@ -2079,12 +2143,16 @@ class CTE(BaseModel):
             return self.parent_ctes[0].name
         return self.name
 
-    def get_alias(self, concept: Concept) -> str:
+    def get_alias(self, concept: Concept, source: str | None = None) -> str:
         for cte in self.parent_ctes:
             if concept.address in [x.address for x in cte.output_columns]:
+                if source and source != cte.name:
+                    continue
                 return concept.safe_address
         try:
-            source = self.source.get_alias(concept)
+            source = self.source.get_alias(concept, source=source)
+            if not source:
+                raise ValueError("No source found")
             return source
         except ValueError as e:
             return f"INVALID_ALIAS: {str(e)}"
@@ -2097,6 +2165,11 @@ class CTE(BaseModel):
             and not self.group_to_grain
         ):
             return False
+        if (
+            len(self.source.datasources) == 1
+            and self.source.datasources[0].name == CONSTANT_DATASET
+        ):
+            return False
         return True
 
     @property
@@ -2130,19 +2203,43 @@ class JoinKey(BaseModel):
 
 
 class Join(BaseModel):
-    left_cte: CTE
-    right_cte: CTE
+    left_cte: CTE | Datasource
+    right_cte: CTE | Datasource
     jointype: JoinType
     joinkeys: List[JoinKey]
 
+    @property
+    def left_name(self) -> str:
+        if isinstance(self.left_cte, Datasource):
+            return self.left_cte.identifier
+        return self.left_cte.name
+
+    @property
+    def right_name(self) -> str:
+        if isinstance(self.right_cte, Datasource):
+            return self.right_cte.identifier
+        return self.right_cte.name
+
+    @property
+    def left_ref(self) -> str:
+        if isinstance(self.left_cte, Datasource):
+            return f"{self.left_cte.safe_location} as {self.left_cte.identifier}"
+        return self.left_cte.name
+
+    @property
+    def right_ref(self) -> str:
+        if isinstance(self.right_cte, Datasource):
+            return f"{self.right_cte.safe_location} as {self.right_cte.identifier}"
+        return self.right_cte.name
+
     @property
     def unique_id(self) -> str:
-        return self.left_cte.name + self.right_cte.name + self.jointype.value
+        return self.left_name + self.right_name + self.jointype.value
 
     def __str__(self):
         return (
-            f"{self.jointype.value} JOIN {self.left_cte.name} and"
-            f" {self.right_cte.name} on {','.join([str(k) for k in self.joinkeys])}"
+            f"{self.jointype.value} JOIN {self.left_name} and"
+            f" {self.right_name} on {','.join([str(k) for k in self.joinkeys])}"
         )