spinta 0.2.dev19__py3-none-any.whl → 0.2.dev21__py3-none-any.whl

spinta/adapters/rc/__init__.py

@@ -0,0 +1 @@
+"""Organization-specific SOAP helpers (e.g. RC broker request signing)."""

spinta/adapters/rc/signature_adapter.py

@@ -0,0 +1,118 @@
+import base64
+import subprocess
+
+from lxml import etree
+
+from spinta.components import Context
+from spinta.core.config import RawConfig
+from spinta.core.ufuncs import Expr
+from spinta.datasets.backends.dataframe.backends.soap.ufuncs.components import SoapQueryBuilder
+from spinta.datasets.backends.dataframe.backends.soap.ufuncs.ufuncs import MakeCDATA
+
+RC_ACTION_TYPE_FIELD = "ActionType"
+RC_CALLER_CODE_FIELD = "CallerCode"
+RC_END_USER_INFO_FIELD = "EndUserInfo"
+RC_PARAMETERS_FIELD = "Parameters"
+RC_TIME_FIELD = "Time"
+
+
+def is_quoted(value: str) -> bool:
+    """True if ``value`` has matching outer ``'`` or ``"`` quotes (Katalogas ``is_quoted``)."""
+    return len(value) > 1 and value[0] == value[-1] and value[0] in ('"', "'")
+
+
+def _require_rc_private_key_path(raw_config: RawConfig | None) -> str:
+    """Return the configured PEM path, or raise if raw config / key path is missing."""
+    if raw_config is None:
+        raise RuntimeError("RC signature adapter was loaded but application configuration is missing.")
+    path = raw_config.get("rc_signature", "private_key_path", default=None)
+    if not path or not str(path).strip():
+        raise RuntimeError(
+            "When using the RC signature SOAP adapter, set `rc_signature.private_key_path` in configuration."
+        )
+    return str(path)
+
+
+def validate_soap_adapter_config(raw_config: RawConfig | None) -> None:
+    """Invoked by soap plugin loader when this module is listed in ``soap_adapter_modules``."""
+    _require_rc_private_key_path(raw_config)
+
+
+def _get_private_key_path(context: Context) -> str:
+    return _require_rc_private_key_path(context.get("rc"))
+
+
+def _compute_rc_signature(args: str, key_path: str) -> str:
+    """Compute RC-style signature using openssl CLI.
+    This mirrors the legacy shell example:
+        echo -n "$ARGS" | openssl dgst -sha256 -sign $PRIVATE_KEY_FILE | base64 -w0
+    """
+    proc = subprocess.run(
+        ["openssl", "dgst", "-sha256", "-sign", key_path],
+        input=args.encode("utf-8"),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        check=True,
+    )
+    sig_b64 = base64.b64encode(proc.stdout).decode("ascii")
+
+    return sig_b64.replace("\r", "").replace("\n", "")
+
+
+def build_rc_string_to_sign(soap_body: dict[str, object]) -> str:
+    """Return the plaintext that RC signs and verifies for SOAP calls.
+
+    The broker does not sign the whole XML; it expects an RSA-SHA256 signature over one
+    concatenated string, in this exact order with no delimiters: ActionType, CallerCode,
+    EndUserInfo, Parameters, Time. The server rebuilds the same string and checks the
+    signature, so we must assemble identical pieces from `soap_body`.
+    """
+
+    input_block = soap_body.get("input")
+    input_dict = input_block if isinstance(input_block, dict) else None
+
+    def _get(name: str, default: str = "") -> str:
+        value = soap_body.get(f"input/{name}")
+        if value is None and input_dict is not None:
+            value = input_dict.get(name)
+
+        if value is None:
+            value = soap_body.get(name, default)
+
+        if isinstance(value, MakeCDATA):
+            value = value.data
+
+        if isinstance(value, etree.CDATA):
+            value = str(value)
+
+        if name == RC_PARAMETERS_FIELD and isinstance(value, str) and is_quoted(value):
+            value = value[1:-1]
+
+        return "" if value is None else str(value)
+
+    action_type = _get(RC_ACTION_TYPE_FIELD)
+    caller_code = _get(RC_CALLER_CODE_FIELD)
+    end_user_info = _get(RC_END_USER_INFO_FIELD, "")
+    parameters = _get(RC_PARAMETERS_FIELD, "")
+    time_value = _get(RC_TIME_FIELD)
+
+    return f"{action_type}{caller_code}{end_user_info}{parameters}{time_value}"
+
+
+def compute_rc_signature_from_body(soap_body: dict[str, object], context: Context) -> str:
+    """Build string-to-sign from soap_body and return base64 signature."""
+    key_path = _get_private_key_path(context)
+    args = build_rc_string_to_sign(soap_body)
+
+    return _compute_rc_signature(args, key_path)
+
+
+def get_deferred_prepare_names() -> list[str]:
+    return ["rc_signature"]
+
+
+def get_body_resolvers() -> dict[str, object]:
+    def rc_signature_resolver(env: SoapQueryBuilder, expr: Expr | None = None) -> str:
+        return compute_rc_signature_from_body(env.soap_request_body, env.context)
+
+    return {"rc_signature": rc_signature_resolver}

spinta/adapters/soap_plugins.py

@@ -0,0 +1,122 @@
+"""Load optional SOAP adapter modules from ``soap_adapter_modules`` paths in config."""
+
+import importlib.util
+import logging
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Callable
+
+from spinta.core.ufuncs import Expr, UFuncRegistry
+from spinta.core.config import RawConfig
+from spinta.ufuncs.loadbuilder.components import LoadBuilder
+from spinta.datasets.backends.dataframe.backends.soap.ufuncs.components import SoapQueryBuilder
+
+log = logging.getLogger(__name__)
+
+
+_deferred_prepare_names_cache: set[str] | None = None
+
+
+def get_deferred_prepare_names() -> set[str]:
+    """Names of prepare ufuncs left unresolved until the SOAP body is built (empty before register)."""
+    return _deferred_prepare_names_cache or set()
+
+
+def _load_adapter_module_from_path(file_path: str, raw_config: RawConfig | None = None) -> ModuleType | None:
+    try:
+        path = Path(file_path)
+        if not path.exists():
+            log.warning("SOAP adapter module not found: %s", file_path)
+            return None
+        spec = importlib.util.spec_from_file_location(path.stem, path)
+        if spec is None or spec.loader is None:
+            log.warning("Failed to create module spec for: %s", file_path)
+            return None
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        log.info("Loaded SOAP adapter module from: %s", file_path)
+        if hasattr(module, "validate_soap_adapter_config"):
+            module.validate_soap_adapter_config(raw_config)
+        return module
+    except Exception as e:
+        log.warning("Failed to load SOAP adapter module %s: %s", file_path, e)
+        return None
+
+
+def _load_adapters_from_config(raw_config: RawConfig | None) -> tuple[set[str], dict[str, Callable[..., Any]]]:
+    deferred: set[str] = set()
+    body_resolvers: dict[str, Callable[..., Any]] = {}
+
+    if raw_config is None:
+        return deferred, body_resolvers
+
+    module_paths = raw_config.get("soap_adapter_modules", default=[])
+    if not module_paths:
+        return deferred, body_resolvers
+
+    if isinstance(module_paths, str):
+        module_paths = [module_paths]
+
+    for module_path in module_paths:
+        module = _load_adapter_module_from_path(module_path, raw_config)
+        if module is None:
+            continue
+
+        if hasattr(module, "get_deferred_prepare_names"):
+            try:
+                result = module.get_deferred_prepare_names()
+            except Exception as e:
+                log.warning("Failed to call get_deferred_prepare_names in %s: %s", module_path, e)
+            else:
+                if isinstance(result, (list, tuple)):
+                    deferred.update(result)
+                else:
+                    deferred.add(str(result))
+
+        if hasattr(module, "get_body_resolvers"):
+            try:
+                result = module.get_body_resolvers()
+            except Exception as e:
+                log.warning("Failed to call get_body_resolvers in %s: %s", module_path, e)
+            else:
+                if isinstance(result, dict):
+                    body_resolvers.update(result)
+
+    return deferred, body_resolvers
+
+
+def _deferred_prepare_resolver(env, expr: Expr) -> Expr:
+    env.param.soap_body = {env.this: expr}
+    return expr
+
+
+def _make_body_resolver(callable_fn: Callable[..., Any]) -> Callable[[SoapQueryBuilder, Expr], Any]:
+    """Adapter may implement ``fn(env)`` only; fall back if ``fn(env, expr)`` raises ``TypeError``."""
+
+    def body_resolver(env: SoapQueryBuilder, expr: Expr) -> Any:
+        try:
+            return callable_fn(env, expr)
+        except TypeError:
+            return callable_fn(env)
+
+    return body_resolver
+
+
+def register_soap_ufuncs(registry: UFuncRegistry, raw_config: RawConfig | None = None) -> None:
+    """Register SOAP adapter resolvers from config (`soap_adapter_modules`).
+    Adapters are loaded from local Python files listed in:
+        soap_adapter_modules:
+          - /path/to/adapter.py
+    Call this after resolver.collect().
+    """
+    global _deferred_prepare_names_cache
+
+    deferred, body_resolvers = _load_adapters_from_config(raw_config)
+
+    _deferred_prepare_names_cache = deferred
+
+    for name in deferred:
+        registry.register(name, _deferred_prepare_resolver, (LoadBuilder, Expr))
+
+    for name, callable_fn in body_resolvers.items():
+        registry.register(name, _make_body_resolver(callable_fn), (SoapQueryBuilder, Expr))

spinta/backends/helpers.py

@@ -1,12 +1,14 @@
+from __future__ import annotations
+
+import dataclasses
 from typing import Any
-from typing import Dict
 from typing import Iterable
 from typing import Iterator
-from typing import List
-from typing import Optional
-from typing import Tuple
 from typing import TypeVar
-from typing import Union
+
+import sqlalchemy as sa
+
+from multipledispatch import dispatch
 
 from spinta import commands
 from spinta import exceptions
@@ -14,6 +16,7 @@ from spinta import spyna
 from spinta.auth import authorized
 from spinta.backends import Backend
 from spinta.backends.components import SelectTree
+from spinta.backends.postgresql.helpers import get_pg_name
 from spinta.commands import build_full_response
 from spinta.components import Config, DataItem
 from spinta.core.enums import Action
@@ -28,6 +31,11 @@ from spinta.utils.data import take
 from spinta.backends.constants import TableType, BackendOrigin
 
 
+from sqlalchemy.dialects import postgresql
+
+pg_identifier_preparer = postgresql.dialect().identifier_preparer
+
+
 def validate_and_return_transaction(context: Context, backend: Backend, **kwargs):
     if not backend.available:
         backend.available = commands.wait(context, backend)
@@ -51,7 +59,7 @@ def validate_and_return_begin(context: Context, backend: Backend, **kwargs):
 
 
 def load_backend(
-    context: Context, component: Component, name: str, origin: BackendOrigin, data: Dict[str, str]
+    context: Context, component: Component, name: str, origin: BackendOrigin, data: dict[str, str]
 ) -> Backend:
     config = context.get("config")
     type_ = data.get("type")
@@ -77,7 +85,7 @@ def load_backend(
 def get_select_tree(
     context: Context,
     action: Action,
-    select: Optional[List[str]],
+    select: list[str] | None,
 ) -> SelectTree:
     if isinstance(select, dict):
         select = list(select.keys())
@@ -92,8 +100,8 @@ def get_select_tree(
 def _apply_always_show_id(
     context: Context,
     action: Action,
-    select: Optional[List[str]],
-) -> Optional[List[str]]:
+    select: list[str] | None,
+) -> list[str] | None:
     if action in (Action.GETALL, Action.SEARCH):
         config = context.get("config")
         if config.always_show_id:
@@ -106,18 +114,18 @@ def _apply_always_show_id(
 
 def get_select_prop_names(
     context: Context,
-    node: Union[Model, Property, DataType],
-    props: Dict[str, Property],
+    node: Model | Property | DataType,
+    props: dict[str, Property],
     action: Action,
     select: SelectTree,
     *,
     # If False, do not check if client has access to this property.
     auth: bool = True,
     # Allowed reserved property names.
-    reserved: List[str] = None,
+    reserved: list[str] = None,
     # If False, do not include Denorm type props
     include_denorm_props: bool = True,
-) -> List[str]:
+) -> list[str]:
     known = set(reserved or []) | set(take(props))
     check_unknown_props(node, select, known)
 
@@ -138,13 +146,13 @@ def get_select_prop_names(
 
 def select_model_props(
     model: Model,
-    prop_names: List[str],
+    prop_names: list[str],
     value: dict,
     select: SelectTree,
-    reserved: List[str],
+    reserved: list[str],
 ) -> Iterator[
-    Tuple[
-        Union[Property, str],
+    tuple[
+        Property | str,
         Any,
         SelectTree,
     ]
@@ -170,16 +178,16 @@ T = TypeVar("T")
 
 
 def select_props(
-    node: Union[Namespace, Model, Property],
+    node: Namespace | Model | Property,
     keys: Iterable[str],
-    props: Dict[str, Property],
-    value: Dict[str, T],
+    props: dict[str, Property],
+    value: dict[str, T],
     select: SelectTree,
     *,
     reserved: bool = True,
 ) -> Iterator[
-    Tuple[
-        Union[Property, str],
+    tuple[
+        Property | str,
         T,
         SelectTree,
     ]
@@ -191,15 +199,15 @@ def select_props(
 
 
 def select_only_props(
-    node: Union[Namespace, Model, Property],
+    node: Namespace | Model | Property,
     keys: Iterable[str],
-    props: Dict[str, Property],
+    props: dict[str, Property],
     select: SelectTree,
     *,
     reserved: bool = True,
 ) -> Iterator[
-    Tuple[
-        Union[Property, str],
+    tuple[
+        Property | str,
         SelectTree,
     ]
 ]:
@@ -211,9 +219,9 @@ def select_only_props(
 
 def _select_prop(
     key: str,
-    props: Dict[str, Property],
-    node: Union[Namespace, Model, Property],
-) -> Optional[Property]:
+    props: dict[str, Property],
+    node: Namespace | Model | Property,
+) -> Property | None:
     if not (prop := props.get(key)) or prop.hidden:
         return None
 
@@ -222,12 +230,12 @@ def _select_prop(
 
 def select_keys(
     keys: Iterable[str],
-    value: Dict[str, T],
+    value: dict[str, T],
     select: SelectTree,
     *,
     reserved: bool = True,
 ) -> Iterator[
-    Tuple[
+    tuple[
         str,
         T,
         SelectTree,
@@ -253,7 +261,7 @@ def select_only_keys(
     *,
     reserved: bool = True,
 ) -> Iterator[
-    Tuple[
+    tuple[
         str,
         SelectTree,
     ]
@@ -280,8 +288,8 @@ def select_only_keys(
 # FIXME: We should check select list at the very beginning of
 #        request, not when returning results.
 def check_unknown_props(
-    node: Union[Model, Property, DataType],
-    select: Optional[Iterable[str]],
+    node: Model | Property | DataType,
+    select: Iterable[str] | None,
     known: Iterable[str],
 ):
     unknown_properties = set(select or []) - set(known) - {"*"}
@@ -291,7 +299,7 @@ def check_unknown_props(
         )
 
 
-def flat_select_to_nested(select: Optional[List[str]]) -> SelectTree:
+def flat_select_to_nested(select: list[str] | None) -> SelectTree:
     """
     >>> flat_select_to_nested(None)
 
@@ -316,7 +324,7 @@ def flat_select_to_nested(select: Optional[List[str]]) -> SelectTree:
     return res
 
 
-def get_model_reserved_props(action: Action, include_page: bool) -> List[str]:
+def get_model_reserved_props(action: Action, include_page: bool) -> list[str]:
     if action == Action.GETALL:
         reserved = ["_type", "_id", "_revision"]
     elif action == Action.SEARCH:
@@ -332,12 +340,145 @@ def get_model_reserved_props(action: Action, include_page: bool) -> List[str]:
     return reserved
 
 
-def get_ns_reserved_props(action: Action) -> List[str]:
+def get_ns_reserved_props(action: Action) -> list[str]:
     return []
 
 
+@dataclasses.dataclass
+class TableIdentifier:
+    """
+    Represents a table identifier across logical (app) and PostgreSQL layers.
+
+    It builds derived names used for internal logic and SQL queries, including
+    schema-qualified and escaped identifiers.
+
+    Attributes:
+        schema (str | None): Logical schema/namespace (e.g. "datasets/gov/rc").
+        base_name (str): Base table name (e.g. "Building").
+        table_type (TableType): Table type suffix (default: TableType.MAIN).
+        table_arg (str | None): Optional argument appended used for table types that require property.
+        default_pg_schema (str | None): Fallback PG schema if schema is not given.
+
+        logical_name (str): Computed name (base + type + optional arg).
+            Example: "Building/:list/apartments"
+        logical_qualified_name (str): Logical name with schema (dataset).
+            Example: "datasets/gov/rc/Building/:list/apartments"
+
+        pg_table_name (str): PG-safe (compressed) table name from logical_name.
+        pg_schema_name (str | None): PG-safe (compressed) schema name.
+        pg_qualified_name (str): PG-safe (compressed) schema with table name.
+            Example: "datasets/gov/rc.Building/:list/apartments" (unescaped).
+        pg_escaped_qualified_name (str): Quoted version of pg_qualified_name, used for queries.
+            Example: '"datasets/gov/rc"."Building/:list/apartments"' (escaped).
+
+    Example:
+        >>> TableIdentifier("datasets/gov/rc", "Buildings", TableType.LIST, "apartments")
+        # logical_qualified_name: "datasets/gov/rc/Buildings/:list/apartments"
+        # pg_qualified_name: "datasets/gov/rc.Building/:list/apartments"
+
+        >>> TableIdentifier("datasets/gov/rc", "Buildings")
+        # logical_qualified_name: "datasets/gov/rc/Buildings"
+        # pg_qualified_name: "datasets/gov/rc.Building"
+
+        >>> TableIdentifier("datasets/gov/rc/very/long/dataset/name/that/does/not/fit/withing/limits", "Buildings")
+        # logical_qualified_name: "datasets/gov/rc/very/long/dataset/name/that/does/not/fit/withing/limits/Buildings"
+        # pg_qualified_name: "datasets/gov/rc/very/long/dataset/nam_e5985b69_t/withing/limits.Building"
+    """
+
+    schema: str | None
+    base_name: str
+    table_type: TableType = dataclasses.field(default=TableType.MAIN)
+    table_arg: str | None = dataclasses.field(default=None)
+    default_pg_schema: str | None = dataclasses.field(default=None)
+
+    logical_name: str = dataclasses.field(init=False)
+    # Name with namespace connected with '/', like it is used with Model class
+    logical_qualified_name: str = dataclasses.field(init=False)
+
+    pg_table_name: str = dataclasses.field(init=False)
+    pg_schema_name: str | None = dataclasses.field(init=False)
+    # Used for hashed schema and table names
+    pg_qualified_name: str = dataclasses.field(init=False)
+    # Escaped qualified name, used for queries
+    pg_escaped_qualified_name: str = dataclasses.field(init=False)
+
+    def __post_init__(self):
+        self.logical_name = self.base_name + self.table_type.value
+        if self.table_arg:
+            self.logical_name += "/" + self.table_arg
+
+        self.logical_qualified_name = f"{self.schema}/{self.logical_name}" if self.schema else self.logical_name
+
+        self.pg_table_name = get_pg_name(self.logical_name)
+        self.pg_schema_name = get_pg_name(self.schema) if self.schema else self.default_pg_schema
+        self.pg_qualified_name = (
+            f"{self.pg_schema_name}.{self.pg_table_name}" if self.pg_schema_name else self.pg_table_name
+        )
+        self.pg_escaped_qualified_name = (
+            f"{pg_identifier_preparer.quote(self.pg_schema_name)}.{pg_identifier_preparer.quote(self.pg_table_name)}"
+            if self.pg_schema_name
+            else pg_identifier_preparer.quote(self.pg_table_name)
+        )
+
+    def change_table_type(self, new_type: TableType, table_arg: str | None = None) -> "TableIdentifier":
+        return dataclasses.replace(self, table_type=new_type, table_arg=table_arg)
+
+    def apply_removed_prefix(self, remove_model_only: bool = False) -> "TableIdentifier":
+        if remove_model_only or not self.table_arg:
+            if not self.base_name.startswith("__"):
+                return dataclasses.replace(self, base_name=f"__{self.base_name}")
+            return self
+
+        if not self.table_arg.startswith("__"):
+            return dataclasses.replace(self, table_arg=f"__{self.table_arg}")
+        return self
+
+
+@dispatch(str)
+def get_table_identifier(item: str, **kwargs) -> TableIdentifier:
+    schema, model_name, table_type, table_arg = split_logical_name(item)
+    return TableIdentifier(schema=schema, base_name=model_name, table_type=table_type, table_arg=table_arg, **kwargs)
+
+
+@dispatch(sa.Table)
+def get_table_identifier(item: sa.Table, **kwargs) -> TableIdentifier:
+    if not item.comment:
+        return TableIdentifier(schema=item.schema, base_name=item.name, **kwargs)
+    if item.schema not in ("public", None):
+        return get_table_identifier(item.comment, **kwargs)
+
+    schema, model_name, table_type, table_arg = split_logical_name(item.comment)
+    return TableIdentifier(
+        schema=None,
+        base_name=f"{schema}/{model_name}" if schema else model_name,
+        table_type=table_type,
+        table_arg=table_arg,
+        **kwargs,
+    )
+
+
+@dispatch((Model, Property))
+def get_table_identifier(node: Model | Property, **kwargs) -> TableIdentifier:
+    return get_table_identifier(node, TableType.MAIN, **kwargs)
+
+
+@dispatch((Model, Property), TableType)
+def get_table_identifier(
+    node: Model | Property, table_type: TableType, table_arg: str = None, **kwargs
+) -> TableIdentifier:
+    model = node if isinstance(node, Model) else node.model
+
+    schema = model.ns.name if model.ns else None
+    base_name = model.get_name_without_ns()
+
+    if isinstance(node, Property) and table_type in (TableType.LIST, TableType.FILE):
+        table_arg = node.place
+
+    return TableIdentifier(schema, base_name, table_type, table_arg, **kwargs)
+
+
 def get_table_name(
-    node: Union[Model, Property],
+    node: Model | Property,
     ttype: TableType = TableType.MAIN,
 ) -> str:
     if isinstance(node, Model):
@@ -351,6 +492,27 @@ def get_table_name(
     return name
 
 
+def split_table_name(full_name: str) -> tuple[str | None, str]:
+    parts = full_name.split(".", maxsplit=1)
+    if len(parts) == 1:
+        return None, parts[0]
+    return parts[0], parts[1]
+
+
+def split_logical_name(full_name: str) -> tuple[str | None, str, TableType, str | None]:
+    base_name, table_type, property_name = extract_table_data_from_logical_name(full_name)
+    parts = base_name.split("/")
+    if len(parts) == 1:
+        return None, parts[0], table_type, property_name
+
+    for i, part in enumerate(parts):
+        if part[0].isupper() or (part[:2] == "__" and part[2].isupper()):
+            namespace = "/".join(parts[:i])
+            model = "/".join(parts[i:])
+            return namespace, model, table_type, property_name
+    return None, base_name, table_type, property_name
+
+
 def load_query_builder_class(config: Config, backend: Backend):
     if backend.query_builder_type is None:
         return
@@ -400,3 +562,37 @@ def prepare_response(
     else:
         resp = {}
     return resp
+
+
+def extract_table_data_from_logical_name(table_name: str) -> tuple[str | None, TableType | None, str | None]:
+    """
+    Extracts the main table name, table type, and an optional property suffix from a logical
+    table name string. It parses the given logical table name and determines whether it belongs
+    to the main table or some specific table type. If a specific type is found, it splits the
+    table name into its components.
+
+    Parameters:
+        table_name (str): The logical table name string that needs to be processed.
+
+    Returns:
+        tuple: A tuple containing:
+            - str | None: The main table name.
+            - TableType | None: The type of the table, which can be `MAIN` or other enum members of
+              `TableType`.
+            - str | None: A property suffix string if present in the logical table name, or
+              None otherwise.
+    """
+    if "/:" not in table_name:
+        return table_name, TableType.MAIN, None
+
+    for table_type in TableType:
+        if table_type is TableType.MAIN:
+            continue
+
+        if table_type.value in table_name:
+            data = table_name.split(table_type.value, 1)
+            if data[1]:
+                return data[0], table_type, data[1][1:]  # skip /property slash
+            return data[0], table_type, None
+
+    return None, None, None

spinta/backends/memory/commands/init.py

@@ -2,12 +2,12 @@ from spinta import commands
 from spinta.components import Context
 from spinta.manifests.components import Manifest
 from spinta.backends.constants import TableType
-from spinta.backends.helpers import get_table_name
+from spinta.backends.helpers import get_table_identifier
 from spinta.backends.memory.components import Memory
 
 
 @commands.prepare.register(Context, Memory, Manifest)
 def prepare(context: Context, backend: Memory, manifest: Manifest, **kwargs):
     for model in commands.get_models(context, manifest).values():
-        backend.create(get_table_name(model))
-        backend.create(get_table_name(model, TableType.CHANGELOG))
+        backend.create(get_table_identifier(model).logical_qualified_name)
+        backend.create(get_table_identifier(model, TableType.CHANGELOG).logical_qualified_name)