clm-kernel 0.0.0__py3-none-any.whl

clm/layer2/storage/__init__.py

@@ -0,0 +1,190 @@
+"""Layer 2 Storage Substrate (Sprint 387).
+
+Canonical home for the Tri-Database persistence engine, connection pools,
+CRUD repositories, bitemporal timelines, and hyperlink graph queries.
+Relocated from Layer 0 to preserve Kenotic Microkernel Purity (INV-01, INV-09, INV-10).
+"""
+from __future__ import annotations
+
+import sys
+
+from clm.cross_cutting.clm_logger import get_logger
+from clm.layer0.relations import _scan_cards_containing
+from clm.layer0.relations import query_card_relations as _qcr
+from clm.layer0.utils import clm_hash_string
+
+from .db_bitemporal import BitemporalMixin
+from .db_driver import _ENGINES, CLMDB, reset_shared_socket
+from .db_hyperlinks import HyperlinkMixin
+from .db_pool import ClmDbPool
+from .db_repository import RepositoryBase
+from .savepoint import DisposableList, savepoint
+from .sqlite_wal import SqliteWalPool, TriDatabasePoolRegistry, get_tridb_pools
+
+_logger = get_logger("clm.layer2.storage")
+
+
+class CLMRepository(BitemporalMixin, HyperlinkMixin, RepositoryBase):
+    """DAO/Repository for the MCard three-table schema across the Sovereign Triad.
+
+    Sprint 387: Relocated to Layer 2 Storage. Assembled from RepositoryBase (CRUD),
+    BitemporalMixin (time-travel queries), and HyperlinkMixin (graph traversal).
+    Administrative CLI flows (init_tridb, memorize_mcard) are delegated to
+    clm.layer4.cli.tridb_admin.
+    """
+
+    def init_tridb(self) -> int:
+        """CLI flow: initialize all 3 pillar databases (delegated to Layer 4 CLI)."""
+        target = "clm.layer4.cli.tridb_admin"
+        mod = sys.modules.get(target)
+        if mod is None:
+            __import__(target)
+            mod = sys.modules.get(target)
+        return mod.init_tridb_method(self)
+
+    def memorize_mcard(self, mcard_file: str, pillar: str = "auto") -> int:
+        """CLI flow: memorize an MCard file (delegated to Layer 4 CLI)."""
+        target = "clm.layer4.cli.tridb_admin"
+        mod = sys.modules.get(target)
+        if mod is None:
+            __import__(target)
+            mod = sys.modules.get(target)
+        return mod.memorize_mcard_method(self, mcard_file, pillar)
+
+    def query_card_relations(self, card_hash: str, pillar: str = "execution_log") -> dict[str, list]:
+        """Resolve related cards via SQLite relational calculus."""
+        return _qcr(self, card_hash, pillar)
+
+    def _scan_cards_containing(self, pillar: str, needle: str) -> list:
+        """Scan all cards in a pillar and return parsed Cards whose content mentions needle."""
+        return _scan_cards_containing(self, pillar, needle)
+
+
+def parse_yaml_mcard(mcard_content_str: str):
+    """Extract content_hash, g_time, source filename from MCard YAML."""
+    from clm.cross_cutting.mcard import parse_yaml_mcard as _impl
+    return _impl(mcard_content_str)
+
+
+# Module-level convenience functions
+
+def init_tridb(clm_root: str) -> int:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).init_tridb()
+
+
+def memorize_mcard(clm_root: str, mcard_file: str, pillar: str = "auto") -> int:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).memorize_mcard(mcard_file, pillar)
+
+
+def resolve_handle_hash(clm_root: str, handle_name: str, pillar: str = "content_memory") -> str:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).resolve_handle_hash(handle_name, pillar)
+
+
+def resolve_handle_content(clm_root: str, handle_name: str, pillar: str = "content_memory") -> str:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).resolve_handle_content(handle_name, pillar)
+
+
+def register_handle(clm_root: str, handle_name: str, content_source: str) -> int:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).register_handle(handle_name, content_source)
+
+
+def resolve_handle_hash_at(clm_root: str, handle_name: str, query_time: str, pillar: str = "content_memory") -> str | None:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).resolve_handle_hash_at(handle_name, query_time, pillar)
+
+
+def resolve_handle_content_at(clm_root: str, handle_name: str, query_time: str, pillar: str = "content_memory") -> str | None:
+    db = CLMDB(clm_root)
+    return CLMRepository(db, clm_root).resolve_handle_content_at(handle_name, query_time, pillar)
+
+
+class CardCollection:
+    """Compatibility facade over CLMRepository providing MCard-TDD CardCollection surface.
+
+    Adheres to INV-REF-03 (G-Set Immortality): hard deletes are mathematically forbidden.
+    Calling delete(handle) emits a DeprecationWarning and delegates to tombstone_handle.
+    """
+
+    def __init__(self, repo: CLMRepository | None = None, clm_root: str = "."):
+        if repo is None:
+            db = CLMDB(clm_root)
+            self.repo = CLMRepository(db, clm_root)
+        else:
+            self.repo = repo
+
+    def add(self, card_or_content, pillar: str = "content_memory") -> str:
+        if hasattr(card_or_content, "hash") and hasattr(card_or_content, "content"):
+            h = str(card_or_content.hash)
+            c = card_or_content.content
+            if isinstance(c, bytes):
+                c = c.decode("utf-8", errors="replace")
+            self.repo.save_card(h, c, pillar)
+            return h
+
+        content_str = str(card_or_content)
+        h = clm_hash_string(content_str)
+        self.repo.save_card(h, content_str, pillar)
+        return h
+
+    def get(self, hash_val: str, pillar: str = "content_memory") -> str | None:
+        return self.repo.get_card_content(hash_val, pillar)
+
+    def delete(self, handle: str, pillar: str = "content_memory") -> bool:
+        import warnings
+
+        warnings.warn(
+            "Hard deletion violates G-Set CRDT invariants. Tombstoning handle in handle_history.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.tombstone_handle(handle, pillar)
+
+    def tombstone_handle(self, handle: str, pillar: str = "content_memory") -> bool:
+        return self.repo.tombstone_handle(handle, pillar)
+
+    def clear(self, pillar: str = "content_memory") -> None:
+        import warnings
+
+        warnings.warn(
+            "clear() violates G-Set CRDT invariants. Operation deprecated on CLMRepository.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+
+def __getattr__(name):
+    if name == "_SHARED_SOCKET":
+        from . import db_driver
+        return db_driver._SHARED_SOCKET
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "CLMDB",
+    "CLMRepository",
+    "CardCollection",
+    "ClmDbPool",
+    "RepositoryBase",
+    "BitemporalMixin",
+    "HyperlinkMixin",
+    "savepoint",
+    "DisposableList",
+    "reset_shared_socket",
+    "init_tridb",
+    "memorize_mcard",
+    "resolve_handle_hash",
+    "resolve_handle_content",
+    "register_handle",
+    "resolve_handle_hash_at",
+    "resolve_handle_content_at",
+    "parse_yaml_mcard",
+    "_ENGINES",
+    "SqliteWalPool",
+    "TriDatabasePoolRegistry",
+    "get_tridb_pools",
+]

clm/layer2/storage/db_bitemporal.py

@@ -0,0 +1,141 @@
+"""Bitemporal handle queries (Sprint 133.1 / Sprint 387).
+
+Extracted from ``db.py``. Time-travel queries over the handle_history table:
+resolve handle content/hash at a specific point in time, list all versions,
+and diff two versions.
+
+Canonical Path: clm.layer2.storage.db_bitemporal
+"""
+
+from __future__ import annotations
+
+import difflib
+
+from clm.layer0.exceptions import CLMError, DatabaseError
+
+
+class BitemporalMixin:
+    """Bitemporal query methods for handle version history.
+
+    Mixed into ``CLMRepository`` to provide time-travel queries over the
+    ``handle_history`` table (the η-conversion witness).
+    """
+
+    def get_handle_versions(self, handle_name: str, pillar: str = "content_memory") -> list[dict]:
+        """Returns the chronological list of all active versions of this handle."""
+        sql_registry = "SELECT current_hash, created_at, updated_at FROM handle_registry WHERE handle = ?;"
+        try:
+            res_reg = self.db.execute(pillar, sql_registry, [handle_name])
+            if not res_reg or not res_reg.strip():
+                return []
+            parts = res_reg.strip().split("|")
+            if len(parts) < 3:
+                return []
+            current_hash = parts[0]
+            created_at = parts[1]
+            updated_at = parts[2]
+        except Exception as e:
+            raise DatabaseError(f"Failed to query registry for {handle_name}: {e}") from e
+
+        sql_history = "SELECT previous_hash, changed_at FROM handle_history WHERE handle = ? ORDER BY changed_at ASC;"
+        try:
+            res_hist = self.db.execute(pillar, sql_history, [handle_name])
+            hist_lines = [line.strip() for line in res_hist.strip().split("\n") if line.strip()] if res_hist else []
+        except Exception as e:
+            raise DatabaseError(f"Failed to query history for {handle_name}: {e}") from e
+
+        versions = []
+
+        if not hist_lines:
+            versions.append({
+                "version_index": 0,
+                "hash": current_hash,
+                "active_from": created_at,
+                "active_to": None
+            })
+            return versions
+
+        last_time = created_at
+        idx = 0
+        for line in hist_lines:
+            h_parts = line.split("|")
+            if len(h_parts) >= 2:
+                prev_hash = h_parts[0]
+                changed_at = h_parts[1]
+                versions.append({
+                    "version_index": idx,
+                    "hash": prev_hash,
+                    "active_from": last_time,
+                    "active_to": changed_at
+                })
+                last_time = changed_at
+                idx += 1
+
+        versions.append({
+            "version_index": idx,
+            "hash": current_hash,
+            "active_from": updated_at,
+            "active_to": None
+        })
+
+        return versions
+
+    def resolve_handle_hash_at(self, handle_name: str, query_time: str, pillar: str = "content_memory") -> str | None:
+        """Resolves the hash of a handle as it existed at a specific ISO-8601 query_time."""
+        versions = self.get_handle_versions(handle_name, pillar)
+        if not versions:
+            return None
+
+        q_time = query_time.strip()
+        for ver in versions:
+            active_from = ver["active_from"].strip()
+            active_to = ver["active_to"]
+            if q_time >= active_from and (active_to is None or q_time < active_to.strip()):
+                return ver["hash"]
+        return None
+
+    def resolve_handle_content_at(self, handle_name: str, query_time: str, pillar: str = "content_memory") -> str | None:
+        """Resolves the content of a handle as it existed at a specific ISO-8601 query_time."""
+        hash_val = self.resolve_handle_hash_at(handle_name, query_time, pillar)
+        if not hash_val:
+            return None
+
+        sql = "SELECT content FROM card WHERE hash = ?;"
+        try:
+            res = self.db.execute(pillar, sql, [hash_val])
+            return res.strip() if res else None
+        except Exception as e:
+            raise DatabaseError(f"Failed to resolve content for hash {hash_val} in {pillar}: {e}") from e
+
+    def diff_handle_versions(self, handle_name: str, version_idx1: int, version_idx2: int, pillar: str = "content_memory") -> str:
+        """Compares two versions of a handle's content by chronological indices and returns a diff string."""
+        versions = self.get_handle_versions(handle_name, pillar)
+        if not versions:
+            raise CLMError(f"No versions found for handle '{handle_name}'")
+
+        v1_hash, v2_hash = None, None
+        for ver in versions:
+            if ver["version_index"] == version_idx1:
+                v1_hash = ver["hash"]
+            if ver["version_index"] == version_idx2:
+                v2_hash = ver["hash"]
+
+        if not v1_hash:
+            raise CLMError(f"Version index {version_idx1} not found for handle '{handle_name}'")
+        if not v2_hash:
+            raise CLMError(f"Version index {version_idx2} not found for handle '{handle_name}'")
+
+        sql = "SELECT content FROM card WHERE hash = ?;"
+        c1 = self.db.execute(pillar, sql, [v1_hash])
+        c2 = self.db.execute(pillar, sql, [v2_hash])
+
+        content1 = c1.strip() if c1 else ""
+        content2 = c2.strip() if c2 else ""
+
+        diff = difflib.unified_diff(
+            content1.splitlines(keepends=True),
+            content2.splitlines(keepends=True),
+            fromfile=f"{handle_name} (v{version_idx1}: {v1_hash[:8]})",
+            tofile=f"{handle_name} (v{version_idx2}: {v2_hash[:8]})"
+        )
+        return "".join(diff)

clm/layer2/storage/db_driver.py

@@ -0,0 +1,331 @@
+"""CLMDB — Low-level database driver for the Sovereign Triad (Sprint 133.1 / Sprint 387).
+
+Provides unified SQL execution across the three pillar databases
+(agent_identities, content_memory, execution_log). Supports file-based
+SQLite (via SQLAlchemy / ClmDbPool) or in-memory broker mode
+(CLM_ZERO_FS=true) communicating via TCP socket to clm_memdb_broker.py.
+
+Canonical Path: clm.layer2.storage.db_driver
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import socket
+import sqlite3
+import subprocess
+import sys
+import time
+from typing import Any
+
+from sqlalchemy import create_engine, text
+from sqlalchemy.pool import NullPool
+
+from clm.cross_cutting.clm_logger import get_logger
+from clm.cross_cutting.resources import get_schema_content
+
+_logger = get_logger("clm.db")
+
+_SHARED_SOCKET = None
+_ENGINES: dict[str, Any] = {}
+
+
+def reset_shared_socket() -> None:
+    """Reset the cached shared broker socket (used by tests between runs)."""
+    global _SHARED_SOCKET
+    _SHARED_SOCKET = None
+
+
+class CLMDB:
+    """Low-level database driver for the Sovereign Triad.
+
+    Provides unified SQL execution across the three pillar databases
+    (agent_identities, content_memory, execution_log). Supports two
+    modes: file-based SQLite (via SQLAlchemy) for persistent operation,
+    or in-memory broker mode (CLM_ZERO_FS=true) communicating via TCP
+    socket to clm_memdb_broker.py.
+
+    Each pillar database contains the same three-table MCard Schema,
+    implementing the Three Angles of data identity:
+        card             -> Content addressing (beta / Exponent / CLM C-axis)
+        handle_registry  -> Semantic naming    (alpha / Sum      / CLM A-axis)
+        handle_history   -> Temporal lineage   (eta / Product    / CLM B-axis)
+    """
+
+    def __init__(self, clm_root: str | None = None) -> None:
+        self.clm_root = clm_root or os.environ.get("CLM_ROOT") or os.getcwd()
+        self.zero_fs = os.environ.get("CLM_ZERO_FS", "").lower() == "true"
+        self.port = int(os.environ.get("CLM_MEMBROKER_PORT", "43740"))
+        self.db_dir = os.path.join(self.clm_root, "db")
+
+    def _interpolate_sql(self, sql: str, params: Any) -> str:
+        if not params:
+            return sql
+        idx = 0
+        result = []
+        in_str = False
+        str_char = None
+        i = 0
+        n = len(sql)
+        while i < n:
+            c = sql[i]
+            if c in ("'", '"'):
+                if not in_str:
+                    in_str = True
+                    str_char = c
+                elif str_char == c:
+                    if i + 1 < n and sql[i + 1] == c:
+                        result.append(c * 2)
+                        i += 2
+                        continue
+                    else:
+                        in_str = False
+                result.append(c)
+            elif c == "?" and not in_str:
+                if idx >= len(params):
+                    raise ValueError("Too few parameters for SQL query")
+                val = params[idx]
+                idx += 1
+                if val is None:
+                    result.append("NULL")
+                elif isinstance(val, int | float):
+                    result.append(str(val))
+                elif isinstance(val, bytes):
+                    result.append(f"X'{val.hex()}'")
+                else:
+                    escaped = str(val).replace("'", "''")
+                    result.append(f"'{escaped}'")
+            else:
+                result.append(c)
+            i += 1
+        if idx < len(params):
+            raise ValueError("Too many parameters for SQL query")
+        return "".join(result)
+
+    def _send_to_broker(self, pillar: str, sql: str) -> str:
+        global _SHARED_SOCKET
+        sql_bytes = sql.encode("utf-8")
+        req_header = f"CLMQ\t{pillar}\t{len(sql_bytes)}\t\n".encode()
+
+        for attempt in range(2):
+            s = _SHARED_SOCKET
+            if s is None:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.settimeout(10.0)
+                try:
+                    s.connect(("127.0.0.1", self.port))
+                    _SHARED_SOCKET = s
+                except ConnectionRefusedError:
+                    is_default_port = self.port == 43740
+                    is_externally_managed = "CLM_MEMBROKER_NO_DISK" in os.environ
+                    if self.zero_fs and is_default_port and not is_externally_managed:
+                        broker_script = os.path.join(self.clm_root, "scripts", "bootstrap", "layer0_core", "clm_memdb_broker.py")
+                        if not os.path.exists(broker_script):
+                            broker_script = os.path.join(self.clm_root, "scripts", "layer0_microkernel", "db_core", "clm_memdb_broker.py")
+                        if os.path.exists(broker_script):
+                            subprocess.Popen([sys.executable, broker_script], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+                            retries = 0
+                            connected = False
+                            while retries < 30:
+                                try:
+                                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                                    s.settimeout(10.0)
+                                    s.connect(("127.0.0.1", self.port))
+                                    connected = True
+                                    _SHARED_SOCKET = s
+                                    break
+                                except Exception:
+                                    time.sleep(0.1)
+                                    retries += 1
+                            if not connected:
+                                raise Exception("Failed to lazily start clm_memdb_broker.py") from None
+
+                            try:
+                                schema_sql = get_schema_content("mcard_schema.sql")
+                            except Exception:
+                                schema_sql = ""
+                            if schema_sql:
+                                for p in ("agent_identities", "content_memory", "execution_log"):
+                                    s_schema = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                                    s_schema.settimeout(10.0)
+                                    s_schema.connect(("127.0.0.1", self.port))
+                                    s_bytes = schema_sql.encode("utf-8")
+                                    r_header = f"CLMQ\t{p}\t{len(s_bytes)}\t\n".encode()
+                                    s_schema.sendall(r_header + s_bytes)
+                                    resp_header = b""
+                                    while b"\n" not in resp_header:
+                                        chunk = s_schema.recv(1)
+                                        if not chunk:
+                                            break
+                                        resp_header += chunk
+                                    if resp_header:
+                                        parts = resp_header.decode("utf-8").strip().split("\t")
+                                        if len(parts) >= 3:
+                                            rlen = int(parts[2])
+                                            body = b""
+                                            while len(body) < rlen:
+                                                chunk = s_schema.recv(min(4096, rlen - len(body)))
+                                                if not chunk:
+                                                    break
+                                                body += chunk
+                                    s_schema.close()
+                        else:
+                            raise Exception(f"Broker script not found: {broker_script}") from None
+                    else:
+                        raise
+
+            try:
+                s.sendall(req_header + sql_bytes)
+
+                header_data = b""
+                while b"\n" not in header_data:
+                    chunk = s.recv(1)
+                    if not chunk:
+                        break
+                    header_data += chunk
+
+                if not header_data:
+                    raise Exception("Connection closed without response")
+
+                header_line = header_data.decode("utf-8").strip()
+                parts = header_line.split("\t")
+                if len(parts) < 3 or parts[0] != "CLMR":
+                    raise Exception(f"Invalid response header: {header_line}")
+
+                status, rlen_str = parts[1], parts[2]
+                rlen = int(rlen_str)
+
+                body_bytes = b""
+                while len(body_bytes) < rlen:
+                    chunk = s.recv(min(4096, rlen - len(body_bytes)))
+                    if not chunk:
+                        break
+                    body_bytes += chunk
+
+                if status == "ERR":
+                    raise Exception(body_bytes.decode("utf-8"))
+
+                return body_bytes.decode("utf-8")
+
+            except Exception as e:
+                with contextlib.suppress(Exception):
+                    s.close()
+                _SHARED_SOCKET = None
+
+                if attempt == 1:
+                    raise e
+        return ""
+
+    def execute(self, pillar: str, sql: str, params: Any = None, as_json: bool = False) -> str:
+        if pillar in ("execution_logs", "exec"):
+            pillar = "execution_log"
+        elif pillar in ("agent_identity", "id"):
+            pillar = "agent_identities"
+        elif pillar in ("content_memory", "mem"):
+            pillar = "content_memory"
+
+        if self.zero_fs:
+            interpolated_sql = self._interpolate_sql(sql, params)
+            resp = self._send_to_broker(pillar, interpolated_sql)
+            if as_json:
+                snap_dir = os.environ.get("CLM_MEMBROKER_SNAP_DIR", "/tmp")
+                db_path = os.path.join(snap_dir, f"{pillar}.db")
+                columns = []
+                if os.path.exists(db_path):
+                    try:
+                        conn = sqlite3.connect(db_path)
+                        cursor = conn.cursor()
+                        if "select" in sql.lower():
+                            cursor.execute(sql, params or [])
+                            columns = [col[0] for col in cursor.description] if cursor.description else []
+                        cursor.close()
+                        conn.close()
+                    except Exception:
+                        pass
+
+                rows = []
+                if resp.strip():
+                    for line in resp.strip().split("\n"):
+                        if not line:
+                            continue
+                        vals = line.split("|")
+                        if columns and len(vals) == len(columns):
+                            rows.append(dict(zip(columns, vals, strict=False)))
+                        else:
+                            rows.append({f"col_{i}": val for i, val in enumerate(vals)})
+                return json.dumps(rows)
+            else:
+                return resp
+        else:
+            db_path = os.path.join(self.db_dir, f"{pillar}.db")
+            engine = _ENGINES.get(db_path)
+            if not engine:
+                engine = create_engine(f"sqlite:///{db_path}", poolclass=NullPool)
+                _ENGINES[db_path] = engine
+
+            # Ensure schema exists
+            with engine.begin() as conn:
+                res = conn.execute(text("SELECT 1 FROM sqlite_master WHERE type='table' AND name='card';")).fetchone()
+                if not res:
+                    try:
+                        schema_content = get_schema_content("mcard_schema.sql")
+                    except Exception:
+                        schema_content = ""
+                    if schema_content:
+                        dbapi_conn = conn.connection
+                        if hasattr(dbapi_conn, "executescript"):
+                            dbapi_conn.executescript(schema_content)
+                        elif hasattr(dbapi_conn, "dbapi_connection") and hasattr(dbapi_conn.dbapi_connection, "executescript"):
+                            dbapi_conn.dbapi_connection.executescript(schema_content)
+                        else:
+                            temp_conn = sqlite3.connect(db_path)
+                            temp_conn.executescript(schema_content)
+                            temp_conn.commit()
+                            temp_conn.close()
+
+            with engine.begin() as conn:
+                if params:
+                    if isinstance(params, dict):
+                        result = conn.exec_driver_sql(sql, params)
+                    else:
+                        result = conn.exec_driver_sql(sql, tuple(params))
+                else:
+                    if "BEGIN;" in sql or ";" in sql[:-1]:
+                        dbapi_conn = conn.connection
+                        if hasattr(dbapi_conn, "executescript"):
+                            dbapi_conn.executescript(sql)
+                        elif hasattr(dbapi_conn, "dbapi_connection") and hasattr(dbapi_conn.dbapi_connection, "executescript"):
+                            dbapi_conn.dbapi_connection.executescript(sql)
+                        else:
+                            temp_conn = sqlite3.connect(db_path)
+                            temp_conn.executescript(sql)
+                            temp_conn.commit()
+                            temp_conn.close()
+                        result = None
+                    else:
+                        result = conn.execute(text(sql))
+
+                rows = []
+                columns = []
+                if result is not None:
+                    if result.returns_rows:
+                        rows = result.fetchall()
+                        columns = list(result.keys())
+                    else:
+                        pass
+
+                if as_json:
+                    res_list = []
+                    for row in rows:
+                        res_list.append(dict(zip(columns, row, strict=False)))
+                    result_str = json.dumps(res_list)
+                else:
+                    output = []
+                    for row in rows:
+                        output.append("|".join("" if val is None else str(val) for val in row))
+                    result_str = "\n".join(output) + "\n" if output else ""
+
+                return result_str