datajunction-server 0.0.1a45.dev11__tar.gz → 0.0.1a45.dev12__tar.gz

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datajunction-server
-Version: 0.0.1a45.dev11
+Version: 0.0.1a45.dev12
 Summary: DataJunction server library for running to a DataJunction server
 Project-URL: repository, https://github.com/DataJunction/dj
 Author-email: DataJunction Authors <yian.shang@gmail.com>

datajunction_server-0.0.1a45.dev12/datajunction_server/__about__.py

@@ -0,0 +1,4 @@
+"""
+Version for Hatch
+"""
+__version__ = "0.0.1a45.dev12"

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/api/client.py

@@ -7,7 +7,7 @@ import logging
 
 from fastapi import Depends
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import joinedload, selectinload
 
 from datajunction_server.api.helpers import get_node_by_name
 from datajunction_server.database import Node, NodeRevision
@@ -122,10 +122,18 @@ async def client_code_for_adding_materialization(
     Generate the Python client code used for adding this materialization
     """
     node_short_name = node_name.split(".")[-1]
-    node = await get_node_by_name(session, node_name)
+    node = await Node.get_by_name(
+        session,
+        node_name,
+        options=[
+            joinedload(Node.current).options(
+                selectinload(NodeRevision.materializations),
+            ),
+        ],
+    )
     materialization = [
         materialization
-        for materialization in node.current.materializations
+        for materialization in node.current.materializations  # type: ignore
         if materialization.name == materialization_name
     ][0]
     user_modified_config = {
@@ -141,8 +149,8 @@ async def client_code_for_adding_materialization(
     )
     client_code = f"""dj = DJBuilder(DJ_URL)
 
-{node_short_name} = dj.{node.type}(
-    "{node.name}"
+{node_short_name} = dj.{node.type if node else ""}(
+    "{node.name if node else ""}"
 )
 materialization = MaterializationConfig(
     job="{MaterializationJobTypeEnum.find_match(materialization.job).name.lower()}",

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/api/helpers.py

@@ -519,6 +519,7 @@ async def resolve_downstream_references(
                 .scalar_one()
             )
             await session.refresh(node_revision, ["node"])
+            await session.refresh(downstream_node_revision, ["parents", "missing_parents"])
             downstream_node_revision.parents.append(node_revision.node)
             downstream_node_revision.missing_parents.remove(missing_parent)
             node_validator = await validate_node_data(
@@ -703,20 +704,17 @@ async def validate_cube(  # pylint: disable=too-many-locals
             dimensions.append(columns[column_name_without_role])
 
     if require_dimensions and not dimensions:
-        raise DJException(
-            message=("At least one dimension is required"),
-            http_status_code=http.client.UNPROCESSABLE_ENTITY,
-        )
+        raise DJInvalidInputException(message="At least one dimension is required")
 
     if len(set(catalogs)) > 1:
-        raise DJException(
+        raise DJInvalidInputException(
             message=(
                 f"Metrics and dimensions cannot be from multiple catalogs: {catalogs}"
             ),
         )
 
     if len(set(catalogs)) < 1:  # pragma: no cover
-        raise DJException(
+        raise DJInvalidInputException(
             message=("Metrics and dimensions must be part of a common catalog"),
         )
 

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/config.py

@@ -98,6 +98,10 @@ class Settings(
     db_connect_timeout = 5
     db_pool_pre_ping = True
     db_echo = False
+    db_keepalives = 1
+    db_keepalives_idle = 30
+    db_keepalives_interval = 10
+    db_keepalives_count = 5
 
     @property
     def celery(self) -> Celery:

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/construction/build.py

@@ -437,20 +437,29 @@ async def _build_tables_on_select(
                             for link in node.dimension_links
                             for left, right in link.foreign_key_mapping().items()
                         }
+                        foreign_keys_alias_map = {
+                            col.alias_or_name.name: col  # type: ignore
+                            for col in node_query.select.projection
+                        }
                         if all(
                             col.alias_or_name.name in fk_column_mapping
                             or col.alias_or_name.name in foreign_keys_map
                             for col in referenced_cols
                         ):
+                            # Renames the columns to the foreign key columns
                             for col in referenced_cols:
                                 ref_col_name = (
                                     fk_column_mapping[col.alias_or_name.name].name
                                     if col.alias_or_name.name in fk_column_mapping
                                     else foreign_keys_map[
                                         col.alias_or_name.name
-                                    ].alias_or_name.name
+                                    ].alias_or_name
                                 )
                                 col.name = ast.Name(name=ref_col_name)
+                                if col.alias_or_name.name in foreign_keys_alias_map:
+                                    col.name = foreign_keys_alias_map[  # type: ignore
+                                        col.alias_or_name.name
+                                    ].name
                             filter_asts.append(
                                 temp_select.where,  # type:ignore
                             )

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/errors.py

@@ -1,7 +1,7 @@
 """
 Errors and warnings.
 """
-
+from http import HTTPStatus
 from typing import Any, Dict, List, Literal, Optional, TypedDict
 
 from pydantic.main import BaseModel
@@ -218,6 +218,8 @@ class DJNodeNotFound(DJException):
     Exception raised when a given node name is not found.
     """
 
+    http_status_code: int = HTTPStatus.NOT_FOUND
+
 
 class DJInvalidInputException(DJException):
     """
@@ -225,7 +227,7 @@ class DJInvalidInputException(DJException):
     """
 
     dbapi_exception: DBAPIExceptions = "ProgrammingError"
-    http_status_code: int = 422
+    http_status_code: int = HTTPStatus.UNPROCESSABLE_ENTITY
 
 
 class DJNotImplementedException(DJException):
@@ -252,7 +254,7 @@ class DJAlreadyExistsException(DJException):
     """
 
     dbapi_exception: DBAPIExceptions = "DataError"
-    http_status_code: int = 500
+    http_status_code: int = HTTPStatus.CONFLICT
 
 
 class DJDoesNotExistException(DJException):
@@ -261,7 +263,7 @@ class DJDoesNotExistException(DJException):
     """
 
     dbapi_exception: DBAPIExceptions = "DataError"
-    http_status_code: int = 404
+    http_status_code: int = HTTPStatus.NOT_FOUND
 
 
 class DJQueryServiceClientException(DJException):

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/internal/nodes.py

@@ -982,6 +982,16 @@ def copy_existing_node_revision(old_revision: NodeRevision):
         status=old_revision.status,
         required_dimensions=old_revision.required_dimensions,
         metric_metadata=old_revision.metric_metadata,
+        dimension_links=[
+            DimensionLink(
+                dimension_id=link.dimension_id,
+                join_sql=link.join_sql,
+                join_type=link.join_type,
+                join_cardinality=link.join_cardinality,
+                materialization_conf=link.materialization_conf,
+            )
+            for link in old_revision.dimension_links
+        ],
     )
 
 

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/sql/functions.py

@@ -4013,6 +4013,116 @@ class FunctionRegistryDict(dict):
             ) from exc
 
 
+class NfDateadd(Function):
+    """
+    The result returned is of the same type as input.
+
+    Supported units for dates: Year, month, day, week, quarter Supported units for timestamps:
+    Year, month, day, week, quarter, hour, minute, second, millisecond
+
+    Examples:
+
+    select nf_dateadd(20180531, 2) -> 20180602 as an integer
+    select nf_dateadd(‘2018-05-31’, -10) -> 2018-05-21
+    select nf_dateadd('20180531', 2) -> 20180602 as a string
+    select nf_dateadd('20180531', '-3M') -> 20180228
+    select nf_dateadd('quarter', 1, timestamp '2018-05-31 12:20:21') -> 2018-08-31 12:20:21.000
+    """
+
+
+@NfDateadd.register  # type: ignore
+def infer_type(  # noqa: F811
+    input: Union[ct.IntegerType, ct.StringType, ct.DateType],
+    num_days: ct.IntegerBase,
+) -> Union[ct.IntegerType, ct.StringType, ct.DateType]:
+    return input.type
+
+
+@NfDateadd.register  # type: ignore
+def infer_type(  # noqa: F811
+    input: Union[ct.IntegerType, ct.StringType, ct.DateType],
+    offset: ct.StringType,
+) -> Union[ct.IntegerType, ct.StringType, ct.DateType]:
+    return input.type
+
+
+@NfDateadd.register  # type: ignore
+def infer_type(  # noqa: F811
+    unit: ct.StringType,
+    value: ct.IntegerType,
+    input: Union[ct.IntegerType, ct.StringType, ct.DateType],
+) -> Union[ct.IntegerType, ct.StringType, ct.DateType]:
+    return input.type
+
+
+class NfDateint(Function):
+    """
+    nf_dateint
+    Returns the date as an integer in the format yyyyMMdd.
+
+    Examples:
+
+    select nf_dateint(20180531) -> 20180531
+    select nf_dateint(‘2018-05-31’) -> 20180531
+    select nf_dateint('20180531') -> 20180531
+    select nf_dateint('2018-31-05', 'yyyy-dd-MM') -> 20180531
+    select nf_dateint(1527806973000) -> 20180531
+    select nf_dateint(1527806973) -> 20180531
+    select nf_dateint(date '2018-05-31') -> 20180531
+    select nf_dateint(timestamp '2018-05-31 12:20:21.010') -> 20180531
+    select nf_dateint('2018-05-31T12:20:21.010') -> 20180531
+    """
+
+
+@NfDateint.register  # type: ignore
+def infer_type(  # noqa: F811
+    arg: Union[
+        ct.IntegerType,
+        ct.StringType,
+        ct.TimestampType,
+        ct.DateType,
+        ct.BigIntType,
+        ct.IntegerBase,
+    ],
+) -> ct.IntegerType:
+    return ct.IntegerType()
+
+
+class NfDatediff(Function):
+    """
+    nf_datediff(input1, input2): Returns the number of days (input2-input1).
+                                 Input1 and Input2 must be of the same type.
+    nf_datediff(unit, input1, input2): Returns the difference between the input
+                                       dates in terms of the specified unit
+    Supported intervals: year, quarter,month, week, day, hour, minute, second, millisecond
+
+    Examples:
+
+    select nf_datediff(20180531, 20180604); -> 4
+    select nf_datediff('2018-06-04', '2018-05-31');-> -4
+    select nf_datediff('month', '20180201', '20180531') -> 3
+    select nf_datediff('second', timestamp '2018-05-31 12:20:21',
+        timestamp '2018-05-31 02:20:21') -> -36000
+    """
+
+
+@NfDatediff.register  # type: ignore
+def infer_type(  # noqa: F811
+    input1: Union[ct.IntegerType, ct.StringType, ct.DateType],
+    input2: Union[ct.IntegerType, ct.StringType, ct.DateType],
+) -> ct.IntegerType:
+    return ct.IntegerType()
+
+
+@NfDatediff.register  # type: ignore
+def infer_type(  # noqa: F811
+    unit: ct.StringType,
+    input1: Union[ct.IntegerType, ct.StringType, ct.DateType],
+    input2: Union[ct.IntegerType, ct.StringType, ct.DateType],
+) -> ct.IntegerType:
+    return ct.IntegerType()
+
+
 function_registry = FunctionRegistryDict()
 for cls in Function.__subclasses__():
     snake_cased = re.sub(r"(?<!^)(?=[A-Z])", "_", cls.__name__)

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/datajunction_server/utils.py

@@ -86,6 +86,10 @@ class DatabaseSessionManager:
             poolclass=AsyncAdaptedQueuePool,
             connect_args={
                 "connect_timeout": settings.db_connect_timeout,
+                "keepalives": settings.db_keepalives,
+                "keepalives_idle": settings.db_keepalives_idle,
+                "keepalives_interval": settings.db_keepalives_interval,
+                "keepalives_count": settings.db_keepalives_count,
             },
         )
 

{datajunction_server-0.0.1a45.dev11 → datajunction_server-0.0.1a45.dev12}/tests/api/attributes_test.py

@@ -43,7 +43,7 @@ async def test_adding_new_attribute(
             "allowed_node_types": ["source"],
         },
     )
-    assert response.status_code == 500
+    assert response.status_code == 409
     data = response.json()
     assert data == {
         "message": "Attribute type `internal` already exists!",

datajunction_server-0.0.1a45.dev11/datajunction_server/__about__.py

@@ -1,4 +0,0 @@
-"""
-Version for Hatch
-"""
-__version__ = "0.0.1a45.dev11"