Mercurial > libervia-backend
annotate sat/memory/sqla.py @ 3908:d43b197735d1
tests (unit/AP gateway): add tests for events:
rel 372
author | Goffi <goffi@goffi.org> |
---|---|
date | Thu, 22 Sep 2022 00:01:48 +0200 |
parents | 045af0eeda3f |
children | 1a77e1f866f9 |
rev | line source |
---|---|
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1 #!/usr/bin/env python3 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
2 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
3 # Libervia: an XMPP client |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
4 # Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
5 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
6 # This program is free software: you can redistribute it and/or modify |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
7 # it under the terms of the GNU Affero General Public License as published by |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
8 # the Free Software Foundation, either version 3 of the License, or |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
9 # (at your option) any later version. |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
10 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
11 # This program is distributed in the hope that it will be useful, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
14 # GNU Affero General Public License for more details. |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
15 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
16 # You should have received a copy of the GNU Affero General Public License |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
17 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
18 |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
19 import asyncio |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
20 from asyncio.subprocess import PIPE |
3673
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
21 import copy |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
22 from datetime import datetime |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
23 from pathlib import Path |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
24 import sys |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
25 import time |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
26 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
27 |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
28 from alembic import config as al_config, script as al_script |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
29 from alembic.runtime import migration as al_migration |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
30 from sqlalchemy import and_, delete, event, func, or_, update |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
31 from sqlalchemy import Integer, literal_column, text |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
32 from sqlalchemy.dialects.sqlite import insert |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
33 from sqlalchemy.engine import Connection, Engine |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
34 from sqlalchemy.exc import IntegrityError, NoResultFound |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
35 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
36 from sqlalchemy.future import select |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
37 from sqlalchemy.orm import ( |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
38 contains_eager, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
39 joinedload, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
40 selectinload, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
41 sessionmaker, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
42 subqueryload, |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
43 ) |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
44 from sqlalchemy.orm.attributes import Mapped |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
45 from sqlalchemy.orm.decl_api import DeclarativeMeta |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
46 from sqlalchemy.sql.functions import coalesce, count, now, sum as sum_ |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
47 from twisted.internet import defer |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
48 from twisted.words.protocols.jabber import jid |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
49 from twisted.words.xish import domish |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
50 |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
51 from sat.core import exceptions |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
52 from sat.core.constants import Const as C |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
53 from sat.core.core_types import SatXMPPEntity |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
54 from sat.core.i18n import _ |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
55 from sat.core.log import getLogger |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
56 from sat.memory import migration |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
57 from sat.memory import sqla_config |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
58 from sat.memory.sqla_mapping import ( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
59 Base, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
60 Component, |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
61 File, |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
62 History, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
63 Message, |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
64 NOT_IN_EXTRA, |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
65 ParamGen, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
66 ParamInd, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
67 PrivateGen, |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
68 PrivateGenBin, |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
69 PrivateInd, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
70 PrivateIndBin, |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
71 Profile, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
72 PubsubItem, |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
73 PubsubNode, |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
74 Subject, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
75 SyncState, |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
76 Thread, |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
77 ) |
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
78 from sat.tools.common import uri |
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3862
diff
changeset
|
79 from sat.tools.utils import aio, as_future |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
80 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
81 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
82 log = getLogger(__name__) |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
83 migration_path = Path(migration.__file__).parent |
3664
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
84 #: mapping of Libervia search query operators to SQLAlchemy method name |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
85 OP_MAP = { |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
86 "==": "__eq__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
87 "eq": "__eq__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
88 "!=": "__ne__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
89 "ne": "__ne__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
90 ">": "__gt__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
91 "gt": "__gt__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
92 "<": "__le__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
93 "le": "__le__", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
94 "between": "between", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
95 "in": "in_", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
96 "not_in": "not_in", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
97 "overlap": "in_", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
98 "ioverlap": "in_", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
99 "disjoint": "in_", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
100 "idisjoint": "in_", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
101 "like": "like", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
102 "ilike": "ilike", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
103 "not_like": "notlike", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
104 "not_ilike": "notilike", |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
105 } |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
106 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
107 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
108 @event.listens_for(Engine, "connect") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
109 def set_sqlite_pragma(dbapi_connection, connection_record): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
110 cursor = dbapi_connection.cursor() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
111 cursor.execute("PRAGMA foreign_keys=ON") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
112 cursor.close() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
113 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
114 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
115 class Storage: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
116 |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
117 def __init__(self): |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
118 self.initialized = defer.Deferred() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
119 # we keep cache for the profiles (key: profile name, value: profile id) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
120 # profile id to name |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
121 self.profiles: Dict[str, int] = {} |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
122 # profile id to component entry point |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
123 self.components: Dict[int, str] = {} |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
124 |
3665
72b0e4053ab0
core (memory/slqa): implement `getProfileById`
Goffi <goffi@goffi.org>
parents:
3664
diff
changeset
|
125 def getProfileById(self, profile_id): |
72b0e4053ab0
core (memory/slqa): implement `getProfileById`
Goffi <goffi@goffi.org>
parents:
3664
diff
changeset
|
126 return self.profiles.get(profile_id) |
72b0e4053ab0
core (memory/slqa): implement `getProfileById`
Goffi <goffi@goffi.org>
parents:
3664
diff
changeset
|
127 |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
128 async def migrateApply(self, *args: str, log_output: bool = False) -> None: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
129 """Do a migration command |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
130 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
131 Commands are applied by running Alembic in a subprocess. |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
132 Arguments are alembic executables commands |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
133 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
134 @param log_output: manage stdout and stderr: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
135 - if False, stdout and stderr are buffered, and logged only in case of error |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
136 - if True, stdout and stderr will be logged during the command execution |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
137 @raise exceptions.DatabaseError: something went wrong while running the |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
138 process |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
139 """ |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
140 stdout, stderr = 2 * (None,) if log_output else 2 * (PIPE,) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
141 proc = await asyncio.create_subprocess_exec( |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
142 sys.executable, "-m", "alembic", *args, |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
143 stdout=stdout, stderr=stderr, cwd=migration_path |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
144 ) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
145 log_out, log_err = await proc.communicate() |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
146 if proc.returncode != 0: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
147 msg = _( |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
148 "Can't {operation} database (exit code {exit_code})" |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
149 ).format( |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
150 operation=args[0], |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
151 exit_code=proc.returncode |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
152 ) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
153 if log_out or log_err: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
154 msg += f":\nstdout: {log_out.decode()}\nstderr: {log_err.decode()}" |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
155 log.error(msg) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
156 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
157 raise exceptions.DatabaseError(msg) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
158 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
159 async def createDB(self, engine: AsyncEngine, db_config: dict) -> None: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
160 """Create a new database |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
161 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
162 The database is generated from SQLAlchemy model, then stamped by Alembic |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
163 """ |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
164 # the dir may not exist if it's not the XDG recommended one |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
165 db_config["path"].parent.mkdir(0o700, True, True) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
166 async with engine.begin() as conn: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
167 await conn.run_sync(Base.metadata.create_all) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
168 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
169 log.debug("stamping the database") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
170 await self.migrateApply("stamp", "head") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
171 log.debug("stamping done") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
172 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
173 def _checkDBIsUpToDate(self, conn: Connection) -> bool: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
174 al_ini_path = migration_path / "alembic.ini" |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
175 al_cfg = al_config.Config(al_ini_path) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
176 directory = al_script.ScriptDirectory.from_config(al_cfg) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
177 context = al_migration.MigrationContext.configure(conn) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
178 return set(context.get_current_heads()) == set(directory.get_heads()) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
179 |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
180 async def checkAndUpdateDB(self, engine: AsyncEngine, db_config: dict) -> None: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
181 """Check that database is up-to-date, and update if necessary""" |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
182 async with engine.connect() as conn: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
183 up_to_date = await conn.run_sync(self._checkDBIsUpToDate) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
184 if up_to_date: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
185 log.debug("Database is up-to-date") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
186 else: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
187 log.info("Database needs to be updated") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
188 log.info("updating…") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
189 await self.migrateApply("upgrade", "head", log_output=True) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
190 log.info("Database is now up-to-date") |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
191 |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
192 @aio |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
193 async def initialise(self) -> None: |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
194 log.info(_("Connecting database")) |
3583
16ade4ad63f3
core (memory/sqla_mapping): fix some technical debt:
Goffi <goffi@goffi.org>
parents:
3582
diff
changeset
|
195 |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
196 db_config = sqla_config.getDbConfig() |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
197 engine = create_async_engine( |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
198 db_config["url"], |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
199 future=True, |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
200 ) |
3583
16ade4ad63f3
core (memory/sqla_mapping): fix some technical debt:
Goffi <goffi@goffi.org>
parents:
3582
diff
changeset
|
201 |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
202 new_base = not db_config["path"].exists() |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
203 if new_base: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
204 log.info(_("The database is new, creating the tables")) |
3582
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
205 await self.createDB(engine, db_config) |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
206 else: |
71516731d0aa
core (memory/sqla): database migration using Alembic:
Goffi <goffi@goffi.org>
parents:
3537
diff
changeset
|
207 await self.checkAndUpdateDB(engine, db_config) |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
208 |
3583
16ade4ad63f3
core (memory/sqla_mapping): fix some technical debt:
Goffi <goffi@goffi.org>
parents:
3582
diff
changeset
|
209 self.session = sessionmaker( |
16ade4ad63f3
core (memory/sqla_mapping): fix some technical debt:
Goffi <goffi@goffi.org>
parents:
3582
diff
changeset
|
210 engine, expire_on_commit=False, class_=AsyncSession |
16ade4ad63f3
core (memory/sqla_mapping): fix some technical debt:
Goffi <goffi@goffi.org>
parents:
3582
diff
changeset
|
211 ) |
16ade4ad63f3
core (memory/sqla_mapping): fix some technical debt:
Goffi <goffi@goffi.org>
parents:
3582
diff
changeset
|
212 |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
213 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
214 result = await session.execute(select(Profile)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
215 for p in result.scalars(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
216 self.profiles[p.name] = p.id |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
217 result = await session.execute(select(Component)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
218 for c in result.scalars(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
219 self.components[c.profile_id] = c.entry_point |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
220 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
221 self.initialized.callback(None) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
222 |
3596
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
223 ## Generic |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
224 |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
225 @aio |
3798
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
226 async def get( |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
227 self, |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
228 client: SatXMPPEntity, |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
229 db_cls: DeclarativeMeta, |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
230 db_id_col: Mapped, |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
231 id_value: Any, |
3813
1a10b8b4f169
core (memory/sqla): `session_add` must have a default value in `delete`
Goffi <goffi@goffi.org>
parents:
3798
diff
changeset
|
232 joined_loads = None |
3798
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
233 ) -> Optional[DeclarativeMeta]: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
234 stmt = select(db_cls).where(db_id_col==id_value) |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
235 if client is not None: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
236 stmt = stmt.filter_by(profile_id=self.profiles[client.profile]) |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
237 if joined_loads is not None: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
238 for joined_load in joined_loads: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
239 stmt = stmt.options(joinedload(joined_load)) |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
240 async with self.session() as session: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
241 result = await session.execute(stmt) |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
242 if joined_loads is not None: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
243 result = result.unique() |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
244 return result.scalar_one_or_none() |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
245 |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
246 @aio |
3596
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
247 async def add(self, db_obj: DeclarativeMeta) -> None: |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
248 """Add an object to database""" |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
249 async with self.session() as session: |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
250 async with session.begin(): |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
251 session.add(db_obj) |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
252 |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
253 @aio |
3798
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
254 async def delete( |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
255 self, |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
256 db_obj: Union[DeclarativeMeta, List[DeclarativeMeta]], |
3813
1a10b8b4f169
core (memory/sqla): `session_add` must have a default value in `delete`
Goffi <goffi@goffi.org>
parents:
3798
diff
changeset
|
257 session_add: Optional[List[DeclarativeMeta]] = None |
3798
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
258 ) -> None: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
259 """Delete an object from database |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
260 |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
261 @param db_obj: object to delete or list of objects to delete |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
262 @param session_add: other objects to add to session. |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
263 This is useful when parents of deleted objects needs to be updated too, or if |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
264 other objects needs to be updated in the same transaction. |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
265 """ |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
266 if not db_obj: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
267 return |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
268 if not isinstance(db_obj, list): |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
269 db_obj = [db_obj] |
3596
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
270 async with self.session() as session: |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
271 async with session.begin(): |
3798
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
272 if session_add is not None: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
273 for obj in session_add: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
274 session.add(obj) |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
275 for obj in db_obj: |
b5013bada4b6
core (memory/sqla): generic `get` + `session_add` in `delete`:
Goffi <goffi@goffi.org>
parents:
3797
diff
changeset
|
276 await session.delete(obj) |
3596
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
277 await session.commit() |
2d97c695af05
core (memory/sqla): generic methods to add and delete ORM objects directly
Goffi <goffi@goffi.org>
parents:
3595
diff
changeset
|
278 |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
279 ## Profiles |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
280 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
281 def getProfilesList(self) -> List[str]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
282 """"Return list of all registered profiles""" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
283 return list(self.profiles.keys()) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
284 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
285 def hasProfile(self, profile_name: str) -> bool: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
286 """return True if profile_name exists |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
287 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
288 @param profile_name: name of the profile to check |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
289 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
290 return profile_name in self.profiles |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
291 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
292 def profileIsComponent(self, profile_name: str) -> bool: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
293 try: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
294 return self.profiles[profile_name] in self.components |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
295 except KeyError: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
296 raise exceptions.NotFound("the requested profile doesn't exists") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
297 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
298 def getEntryPoint(self, profile_name: str) -> str: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
299 try: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
300 return self.components[self.profiles[profile_name]] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
301 except KeyError: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
302 raise exceptions.NotFound("the requested profile doesn't exists or is not a component") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
303 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
304 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
305 async def createProfile(self, name: str, component_ep: Optional[str] = None) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
306 """Create a new profile |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
307 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
308 @param name: name of the profile |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
309 @param component: if not None, must point to a component entry point |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
310 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
311 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
312 profile = Profile(name=name) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
313 async with session.begin(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
314 session.add(profile) |
3638
257135d5c5c2
core (memory/sqla): fix key/value inversion in self.profiles
Goffi <goffi@goffi.org>
parents:
3621
diff
changeset
|
315 self.profiles[profile.name] = profile.id |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
316 if component_ep is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
317 async with session.begin(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
318 component = Component(profile=profile, entry_point=component_ep) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
319 session.add(component) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
320 self.components[profile.id] = component_ep |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
321 return profile |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
322 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
323 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
324 async def deleteProfile(self, name: str) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
325 """Delete profile |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
326 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
327 @param name: name of the profile |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
328 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
329 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
330 result = await session.execute(select(Profile).where(Profile.name == name)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
331 profile = result.scalar() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
332 await session.delete(profile) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
333 await session.commit() |
3638
257135d5c5c2
core (memory/sqla): fix key/value inversion in self.profiles
Goffi <goffi@goffi.org>
parents:
3621
diff
changeset
|
334 del self.profiles[profile.name] |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
335 if profile.id in self.components: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
336 del self.components[profile.id] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
337 log.info(_("Profile {name!r} deleted").format(name = name)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
338 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
339 ## Params |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
340 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
341 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
342 async def loadGenParams(self, params_gen: dict) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
343 """Load general parameters |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
344 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
345 @param params_gen: dictionary to fill |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
346 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
347 log.debug(_("loading general parameters from database")) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
348 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
349 result = await session.execute(select(ParamGen)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
350 for p in result.scalars(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
351 params_gen[(p.category, p.name)] = p.value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
352 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
353 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
354 async def loadIndParams(self, params_ind: dict, profile: str) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
355 """Load individual parameters |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
356 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
357 @param params_ind: dictionary to fill |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
358 @param profile: a profile which *must* exist |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
359 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
360 log.debug(_("loading individual parameters from database")) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
361 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
362 result = await session.execute( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
363 select(ParamInd).where(ParamInd.profile_id == self.profiles[profile]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
364 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
365 for p in result.scalars(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
366 params_ind[(p.category, p.name)] = p.value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
367 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
368 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
369 async def getIndParam(self, category: str, name: str, profile: str) -> Optional[str]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
370 """Ask database for the value of one specific individual parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
371 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
372 @param category: category of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
373 @param name: name of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
374 @param profile: %(doc_profile)s |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
375 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
376 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
377 result = await session.execute( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
378 select(ParamInd.value) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
379 .filter_by( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
380 category=category, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
381 name=name, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
382 profile_id=self.profiles[profile] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
383 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
384 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
385 return result.scalar_one_or_none() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
386 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
387 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
388 async def getIndParamValues(self, category: str, name: str) -> Dict[str, str]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
389 """Ask database for the individual values of a parameter for all profiles |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
390 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
391 @param category: category of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
392 @param name: name of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
393 @return dict: profile => value map |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
394 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
395 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
396 result = await session.execute( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
397 select(ParamInd) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
398 .filter_by( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
399 category=category, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
400 name=name |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
401 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
402 .options(subqueryload(ParamInd.profile)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
403 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
404 return {param.profile.name: param.value for param in result.scalars()} |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
405 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
406 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
407 async def setGenParam(self, category: str, name: str, value: Optional[str]) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
408 """Save the general parameters in database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
409 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
410 @param category: category of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
411 @param name: name of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
412 @param value: value to set |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
413 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
414 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
415 stmt = insert(ParamGen).values( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
416 category=category, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
417 name=name, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
418 value=value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
419 ).on_conflict_do_update( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
420 index_elements=(ParamGen.category, ParamGen.name), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
421 set_={ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
422 ParamGen.value: value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
423 } |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
424 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
425 await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
426 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
427 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
428 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
429 async def setIndParam( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
430 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
431 category:str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
432 name: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
433 value: Optional[str], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
434 profile: str |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
435 ) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
436 """Save the individual parameters in database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
437 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
438 @param category: category of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
439 @param name: name of the parameter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
440 @param value: value to set |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
441 @param profile: a profile which *must* exist |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
442 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
443 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
444 stmt = insert(ParamInd).values( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
445 category=category, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
446 name=name, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
447 profile_id=self.profiles[profile], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
448 value=value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
449 ).on_conflict_do_update( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
450 index_elements=(ParamInd.category, ParamInd.name, ParamInd.profile_id), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
451 set_={ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
452 ParamInd.value: value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
453 } |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
454 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
455 await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
456 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
457 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
458 def _jid_filter(self, jid_: jid.JID, dest: bool = False): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
459 """Generate condition to filter on a JID, using relevant columns |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
460 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
461 @param dest: True if it's the destinee JID, otherwise it's the source one |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
462 @param jid_: JID to filter by |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
463 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
464 if jid_.resource: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
465 if dest: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
466 return and_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
467 History.dest == jid_.userhost(), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
468 History.dest_res == jid_.resource |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
469 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
470 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
471 return and_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
472 History.source == jid_.userhost(), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
473 History.source_res == jid_.resource |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
474 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
475 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
476 if dest: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
477 return History.dest == jid_.userhost() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
478 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
479 return History.source == jid_.userhost() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
480 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
481 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
482 async def historyGet( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
483 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
484 from_jid: Optional[jid.JID], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
485 to_jid: Optional[jid.JID], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
486 limit: Optional[int] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
487 between: bool = True, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
488 filters: Optional[Dict[str, str]] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
489 profile: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
490 ) -> List[Tuple[ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
491 str, int, str, str, Dict[str, str], Dict[str, str], str, str, str] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
492 ]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
493 """Retrieve messages in history |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
494 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
495 @param from_jid: source JID (full, or bare for catchall) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
496 @param to_jid: dest JID (full, or bare for catchall) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
497 @param limit: maximum number of messages to get: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
498 - 0 for no message (returns the empty list) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
499 - None for unlimited |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
500 @param between: confound source and dest (ignore the direction) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
501 @param filters: pattern to filter the history results |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
502 @return: list of messages as in [messageNew], minus the profile which is already |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
503 known. |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
504 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
505 # we have to set a default value to profile because it's last argument |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
506 # and thus follow other keyword arguments with default values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
507 # but None should not be used for it |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
508 assert profile is not None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
509 if limit == 0: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
510 return [] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
511 if filters is None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
512 filters = {} |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
513 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
514 stmt = ( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
515 select(History) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
516 .filter_by( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
517 profile_id=self.profiles[profile] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
518 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
519 .outerjoin(History.messages) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
520 .outerjoin(History.subjects) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
521 .outerjoin(History.thread) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
522 .options( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
523 contains_eager(History.messages), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
524 contains_eager(History.subjects), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
525 contains_eager(History.thread), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
526 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
527 .order_by( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
528 # timestamp may be identical for 2 close messages (specially when delay is |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
529 # used) that's why we order ties by received_timestamp. We'll reverse the |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
530 # order when returning the result. We use DESC here so LIMIT keep the last |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
531 # messages |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
532 History.timestamp.desc(), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
533 History.received_timestamp.desc() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
534 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
535 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
536 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
537 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
538 if not from_jid and not to_jid: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
539 # no jid specified, we want all one2one communications |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
540 pass |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
541 elif between: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
542 if not from_jid or not to_jid: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
543 # we only have one jid specified, we check all messages |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
544 # from or to this jid |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
545 jid_ = from_jid or to_jid |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
546 stmt = stmt.where( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
547 or_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
548 self._jid_filter(jid_), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
549 self._jid_filter(jid_, dest=True) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
550 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
551 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
552 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
553 # we have 2 jids specified, we check all communications between |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
554 # those 2 jids |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
555 stmt = stmt.where( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
556 or_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
557 and_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
558 self._jid_filter(from_jid), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
559 self._jid_filter(to_jid, dest=True), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
560 ), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
561 and_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
562 self._jid_filter(to_jid), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
563 self._jid_filter(from_jid, dest=True), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
564 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
565 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
566 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
567 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
568 # we want one communication in specific direction (from somebody or |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
569 # to somebody). |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
570 if from_jid is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
571 stmt = stmt.where(self._jid_filter(from_jid)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
572 if to_jid is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
573 stmt = stmt.where(self._jid_filter(to_jid, dest=True)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
574 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
575 if filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
576 if 'timestamp_start' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
577 stmt = stmt.where(History.timestamp >= float(filters['timestamp_start'])) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
578 if 'before_uid' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
579 # orignially this query was using SQLITE's rowid. This has been changed |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
580 # to use coalesce(received_timestamp, timestamp) to be SQL engine independant |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
581 stmt = stmt.where( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
582 coalesce( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
583 History.received_timestamp, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
584 History.timestamp |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
585 ) < ( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
586 select(coalesce(History.received_timestamp, History.timestamp)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
587 .filter_by(uid=filters["before_uid"]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
588 ).scalar_subquery() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
589 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
590 if 'body' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
591 # TODO: use REGEXP (function to be defined) instead of GLOB: https://www.sqlite.org/lang_expr.html |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
592 stmt = stmt.where(Message.message.like(f"%{filters['body']}%")) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
593 if 'search' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
594 search_term = f"%{filters['search']}%" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
595 stmt = stmt.where(or_( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
596 Message.message.like(search_term), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
597 History.source_res.like(search_term) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
598 )) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
599 if 'types' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
600 types = filters['types'].split() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
601 stmt = stmt.where(History.type.in_(types)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
602 if 'not_types' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
603 types = filters['not_types'].split() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
604 stmt = stmt.where(History.type.not_in(types)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
605 if 'last_stanza_id' in filters: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
606 # this request get the last message with a "stanza_id" that we |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
607 # have in history. This is mainly used to retrieve messages sent |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
608 # while we were offline, using MAM (XEP-0313). |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
609 if (filters['last_stanza_id'] is not True |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
610 or limit != 1): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
611 raise ValueError("Unexpected values for last_stanza_id filter") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
612 stmt = stmt.where(History.stanza_id.is_not(None)) |
3797
cc653b2685f0
core (memory/sqla), plugin XEP-0359: always add `origin-id`, and store:
Goffi <goffi@goffi.org>
parents:
3754
diff
changeset
|
613 if 'origin_id' in filters: |
cc653b2685f0
core (memory/sqla), plugin XEP-0359: always add `origin-id`, and store:
Goffi <goffi@goffi.org>
parents:
3754
diff
changeset
|
614 stmt = stmt.where(History.origin_id == filters["origin_id"]) |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
615 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
616 if limit is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
617 stmt = stmt.limit(limit) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
618 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
619 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
620 result = await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
621 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
622 result = result.scalars().unique().all() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
623 result.reverse() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
624 return [h.as_tuple() for h in result] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
625 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
626 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
627 async def addToHistory(self, data: dict, profile: str) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
628 """Store a new message in history |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
629 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
630 @param data: message data as build by SatMessageProtocol.onMessage |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
631 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
632 extra = {k: v for k, v in data["extra"].items() if k not in NOT_IN_EXTRA} |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
633 messages = [Message(message=mess, language=lang) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
634 for lang, mess in data["message"].items()] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
635 subjects = [Subject(subject=mess, language=lang) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
636 for lang, mess in data["subject"].items()] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
637 if "thread" in data["extra"]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
638 thread = Thread(thread_id=data["extra"]["thread"], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
639 parent_id=data["extra"].get["thread_parent"]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
640 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
641 thread = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
642 try: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
643 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
644 async with session.begin(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
645 session.add(History( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
646 uid=data["uid"], |
3797
cc653b2685f0
core (memory/sqla), plugin XEP-0359: always add `origin-id`, and store:
Goffi <goffi@goffi.org>
parents:
3754
diff
changeset
|
647 origin_id=data["extra"].get("origin_id"), |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
648 stanza_id=data["extra"].get("stanza_id"), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
649 update_uid=data["extra"].get("update_uid"), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
650 profile_id=self.profiles[profile], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
651 source_jid=data["from"], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
652 dest_jid=data["to"], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
653 timestamp=data["timestamp"], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
654 received_timestamp=data.get("received_timestamp"), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
655 type=data["type"], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
656 extra=extra, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
657 messages=messages, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
658 subjects=subjects, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
659 thread=thread, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
660 )) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
661 except IntegrityError as e: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
662 if "unique" in str(e.orig).lower(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
663 log.debug( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
664 f"message {data['uid']!r} is already in history, not storing it again" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
665 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
666 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
667 log.error(f"Can't store message {data['uid']!r} in history: {e}") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
668 except Exception as e: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
669 log.critical( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
670 f"Can't store message, unexpected exception (uid: {data['uid']}): {e}" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
671 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
672 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
673 ## Private values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
674 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
675 def _getPrivateClass(self, binary, profile): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
676 """Get ORM class to use for private values""" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
677 if profile is None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
678 return PrivateGenBin if binary else PrivateGen |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
679 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
680 return PrivateIndBin if binary else PrivateInd |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
681 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
682 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
683 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
684 async def getPrivates( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
685 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
686 namespace:str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
687 keys: Optional[Iterable[str]] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
688 binary: bool = False, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
689 profile: Optional[str] = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
690 ) -> Dict[str, Any]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
691 """Get private value(s) from databases |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
692 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
693 @param namespace: namespace of the values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
694 @param keys: keys of the values to get None to get all keys/values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
695 @param binary: True to deserialise binary values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
696 @param profile: profile to use for individual values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
697 None to use general values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
698 @return: gotten keys/values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
699 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
700 if keys is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
701 keys = list(keys) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
702 log.debug( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
703 f"getting {'general' if profile is None else 'individual'}" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
704 f"{' binary' if binary else ''} private values from database for namespace " |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
705 f"{namespace}{f' with keys {keys!r}' if keys is not None else ''}" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
706 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
707 cls = self._getPrivateClass(binary, profile) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
708 stmt = select(cls).filter_by(namespace=namespace) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
709 if keys: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
710 stmt = stmt.where(cls.key.in_(list(keys))) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
711 if profile is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
712 stmt = stmt.filter_by(profile_id=self.profiles[profile]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
713 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
714 result = await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
715 return {p.key: p.value for p in result.scalars()} |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
716 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
717 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
718 async def setPrivateValue( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
719 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
720 namespace: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
721 key:str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
722 value: Any, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
723 binary: bool = False, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
724 profile: Optional[str] = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
725 ) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
726 """Set a private value in database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
727 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
728 @param namespace: namespace of the values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
729 @param key: key of the value to set |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
730 @param value: value to set |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
731 @param binary: True if it's a binary values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
732 binary values need to be serialised, used for everything but strings |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
733 @param profile: profile to use for individual value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
734 if None, it's a general value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
735 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
736 cls = self._getPrivateClass(binary, profile) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
737 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
738 values = { |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
739 "namespace": namespace, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
740 "key": key, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
741 "value": value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
742 } |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
743 index_elements = [cls.namespace, cls.key] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
744 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
745 if profile is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
746 values["profile_id"] = self.profiles[profile] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
747 index_elements.append(cls.profile_id) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
748 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
749 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
750 await session.execute( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
751 insert(cls).values(**values).on_conflict_do_update( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
752 index_elements=index_elements, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
753 set_={ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
754 cls.value: value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
755 } |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
756 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
757 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
758 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
759 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
760 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
761 async def delPrivateValue( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
762 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
763 namespace: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
764 key: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
765 binary: bool = False, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
766 profile: Optional[str] = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
767 ) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
768 """Delete private value from database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
769 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
770 @param category: category of the privateeter |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
771 @param key: key of the private value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
772 @param binary: True if it's a binary values |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
773 @param profile: profile to use for individual value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
774 if None, it's a general value |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
775 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
776 cls = self._getPrivateClass(binary, profile) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
777 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
778 stmt = delete(cls).filter_by(namespace=namespace, key=key) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
779 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
780 if profile is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
781 stmt = stmt.filter_by(profile_id=self.profiles[profile]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
782 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
783 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
784 await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
785 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
786 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
787 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
788 async def delPrivateNamespace( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
789 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
790 namespace: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
791 binary: bool = False, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
792 profile: Optional[str] = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
793 ) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
794 """Delete all data from a private namespace |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
795 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
796 Be really cautious when you use this method, as all data with given namespace are |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
797 removed. |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
798 Params are the same as for delPrivateValue |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
799 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
800 cls = self._getPrivateClass(binary, profile) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
801 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
802 stmt = delete(cls).filter_by(namespace=namespace) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
803 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
804 if profile is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
805 stmt = stmt.filter_by(profile_id=self.profiles[profile]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
806 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
807 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
808 await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
809 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
810 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
811 ## Files |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
812 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
813 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
814 async def getFiles( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
815 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
816 client: Optional[SatXMPPEntity], |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
817 file_id: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
818 version: Optional[str] = '', |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
819 parent: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
820 type_: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
821 file_hash: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
822 hash_algo: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
823 name: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
824 namespace: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
825 mime_type: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
826 public_id: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
827 owner: Optional[jid.JID] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
828 access: Optional[dict] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
829 projection: Optional[List[str]] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
830 unique: bool = False |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
831 ) -> List[dict]: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
832 """Retrieve files with with given filters |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
833 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
834 @param file_id: id of the file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
835 None to ignore |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
836 @param version: version of the file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
837 None to ignore |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
838 empty string to look for current version |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
839 @param parent: id of the directory containing the files |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
840 None to ignore |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
841 empty string to look for root files/directories |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
842 @param projection: name of columns to retrieve |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
843 None to retrieve all |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
844 @param unique: if True will remove duplicates |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
845 other params are the same as for [setFile] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
846 @return: files corresponding to filters |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
847 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
848 if projection is None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
849 projection = [ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
850 'id', 'version', 'parent', 'type', 'file_hash', 'hash_algo', 'name', |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
851 'size', 'namespace', 'media_type', 'media_subtype', 'public_id', |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
852 'created', 'modified', 'owner', 'access', 'extra' |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
853 ] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
854 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
855 stmt = select(*[getattr(File, f) for f in projection]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
856 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
857 if unique: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
858 stmt = stmt.distinct() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
859 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
860 if client is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
861 stmt = stmt.filter_by(profile_id=self.profiles[client.profile]) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
862 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
863 if public_id is None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
864 raise exceptions.InternalError( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
865 "client can only be omitted when public_id is set" |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
866 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
867 if file_id is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
868 stmt = stmt.filter_by(id=file_id) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
869 if version is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
870 stmt = stmt.filter_by(version=version) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
871 if parent is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
872 stmt = stmt.filter_by(parent=parent) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
873 if type_ is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
874 stmt = stmt.filter_by(type=type_) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
875 if file_hash is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
876 stmt = stmt.filter_by(file_hash=file_hash) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
877 if hash_algo is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
878 stmt = stmt.filter_by(hash_algo=hash_algo) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
879 if name is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
880 stmt = stmt.filter_by(name=name) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
881 if namespace is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
882 stmt = stmt.filter_by(namespace=namespace) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
883 if mime_type is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
884 if '/' in mime_type: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
885 media_type, media_subtype = mime_type.split("/", 1) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
886 stmt = stmt.filter_by(media_type=media_type, media_subtype=media_subtype) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
887 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
888 stmt = stmt.filter_by(media_type=mime_type) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
889 if public_id is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
890 stmt = stmt.filter_by(public_id=public_id) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
891 if owner is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
892 stmt = stmt.filter_by(owner=owner) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
893 if access is not None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
894 raise NotImplementedError('Access check is not implemented yet') |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
895 # a JSON comparison is needed here |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
896 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
897 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
898 result = await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
899 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
900 return [dict(r) for r in result] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
901 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
902 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
903 async def setFile( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
904 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
905 client: SatXMPPEntity, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
906 name: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
907 file_id: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
908 version: str = "", |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
909 parent: str = "", |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
910 type_: str = C.FILE_TYPE_FILE, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
911 file_hash: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
912 hash_algo: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
913 size: int = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
914 namespace: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
915 mime_type: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
916 public_id: Optional[str] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
917 created: Optional[float] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
918 modified: Optional[float] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
919 owner: Optional[jid.JID] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
920 access: Optional[dict] = None, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
921 extra: Optional[dict] = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
922 ) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
923 """Set a file metadata |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
924 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
925 @param client: client owning the file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
926 @param name: name of the file (must not contain "/") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
927 @param file_id: unique id of the file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
928 @param version: version of this file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
929 @param parent: id of the directory containing this file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
930 Empty string if it is a root file/directory |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
931 @param type_: one of: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
932 - file |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
933 - directory |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
934 @param file_hash: unique hash of the payload |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
935 @param hash_algo: algorithm used for hashing the file (usually sha-256) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
936 @param size: size in bytes |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
937 @param namespace: identifier (human readable is better) to group files |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
938 for instance, namespace could be used to group files in a specific photo album |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
939 @param mime_type: media type of the file, or None if not known/guessed |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
940 @param public_id: ID used to server the file publicly via HTTP |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
941 @param created: UNIX time of creation |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
942 @param modified: UNIX time of last modification, or None to use created date |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
943 @param owner: jid of the owner of the file (mainly useful for component) |
3621
9e1a993ad1bf
core (memory/sqla): minor docstring line lenght fix
Goffi <goffi@goffi.org>
parents:
3596
diff
changeset
|
944 @param access: serialisable dictionary with access rules. See [memory.memory] for |
9e1a993ad1bf
core (memory/sqla): minor docstring line lenght fix
Goffi <goffi@goffi.org>
parents:
3596
diff
changeset
|
945 details |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
946 @param extra: serialisable dictionary of any extra data |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
947 will be encoded to json in database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
948 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
949 if mime_type is None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
950 media_type = media_subtype = None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
951 elif '/' in mime_type: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
952 media_type, media_subtype = mime_type.split('/', 1) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
953 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
954 media_type, media_subtype = mime_type, None |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
955 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
956 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
957 async with session.begin(): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
958 session.add(File( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
959 id=file_id, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
960 version=version.strip(), |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
961 parent=parent, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
962 type=type_, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
963 file_hash=file_hash, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
964 hash_algo=hash_algo, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
965 name=name, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
966 size=size, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
967 namespace=namespace, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
968 media_type=media_type, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
969 media_subtype=media_subtype, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
970 public_id=public_id, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
971 created=time.time() if created is None else created, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
972 modified=modified, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
973 owner=owner, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
974 access=access, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
975 extra=extra, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
976 profile_id=self.profiles[client.profile] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
977 )) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
978 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
979 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
980 async def fileGetUsedSpace(self, client: SatXMPPEntity, owner: jid.JID) -> int: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
981 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
982 result = await session.execute( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
983 select(sum_(File.size)).filter_by( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
984 owner=owner, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
985 type=C.FILE_TYPE_FILE, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
986 profile_id=self.profiles[client.profile] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
987 )) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
988 return result.scalar_one_or_none() or 0 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
989 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
990 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
991 async def fileDelete(self, file_id: str) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
992 """Delete file metadata from the database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
993 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
994 @param file_id: id of the file to delete |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
995 NOTE: file itself must still be removed, this method only handle metadata in |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
996 database |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
997 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
998 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
999 await session.execute(delete(File).filter_by(id=file_id)) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1000 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1001 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1002 @aio |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1003 async def fileUpdate( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1004 self, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1005 file_id: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1006 column: str, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1007 update_cb: Callable[[dict], None] |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1008 ) -> None: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1009 """Update a column value using a method to avoid race conditions |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1010 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1011 the older value will be retrieved from database, then update_cb will be applied to |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1012 update it, and file will be updated checking that older value has not been changed |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1013 meanwhile by an other user. If it has changed, it tries again a couple of times |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1014 before failing |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1015 @param column: column name (only "access" or "extra" are allowed) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1016 @param update_cb: method to update the value of the colum |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1017 the method will take older value as argument, and must update it in place |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1018 update_cb must not care about serialization, |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1019 it get the deserialized data (i.e. a Python object) directly |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1020 @raise exceptions.NotFound: there is not file with this id |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1021 """ |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1022 if column not in ('access', 'extra'): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1023 raise exceptions.InternalError('bad column name') |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1024 orm_col = getattr(File, column) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1025 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1026 for i in range(5): |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1027 async with self.session() as session: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1028 try: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1029 value = (await session.execute( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1030 select(orm_col).filter_by(id=file_id) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1031 )).scalar_one() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1032 except NoResultFound: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1033 raise exceptions.NotFound |
3673
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
1034 old_value = copy.deepcopy(value) |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1035 update_cb(value) |
3673
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
1036 stmt = update(File).filter_by(id=file_id).values({column: value}) |
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
1037 if not old_value: |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1038 # because JsonDefaultDict convert NULL to an empty dict, we have to |
3673
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
1039 # test both for empty dict and None when we have an empty dict |
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
1040 stmt = stmt.where((orm_col == None) | (orm_col == old_value)) |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1041 else: |
3673
bd13391ee29e
core (memory/sqla): fix `fileUpdate`
Goffi <goffi@goffi.org>
parents:
3665
diff
changeset
|
1042 stmt = stmt.where(orm_col == old_value) |
3537
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1043 result = await session.execute(stmt) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1044 await session.commit() |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1045 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1046 if result.rowcount == 1: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1047 break |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1048 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1049 log.warning( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1050 _("table not updated, probably due to race condition, trying again " |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1051 "({tries})").format(tries=i+1) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1052 ) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1053 |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1054 else: |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1055 raise exceptions.DatabaseError( |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1056 _("Can't update file {file_id} due to race condition") |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1057 .format(file_id=file_id) |
f9a5b810f14d
core (memory/storage): backend storage is now based on SQLAlchemy
Goffi <goffi@goffi.org>
parents:
diff
changeset
|
1058 ) |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1059 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1060 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1061 async def getPubsubNode( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1062 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1063 client: SatXMPPEntity, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1064 service: jid.JID, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1065 name: str, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1066 with_items: bool = False, |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1067 with_subscriptions: bool = False, |
3862
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1068 create: bool = False, |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1069 create_kwargs: Optional[dict] = None |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1070 ) -> Optional[PubsubNode]: |
3862
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1071 """Retrieve a PubsubNode from DB |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1072 |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1073 @param service: service hosting the node |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1074 @param name: node's name |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1075 @param with_items: retrieve items in the same query |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1076 @param with_subscriptions: retrieve subscriptions in the same query |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1077 @param create: if the node doesn't exist in DB, create it |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1078 @param create_kwargs: keyword arguments to use with ``setPubsubNode`` if the node |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1079 needs to be created. |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1080 """ |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1081 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1082 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1083 select(PubsubNode) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1084 .filter_by( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1085 service=service, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1086 name=name, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1087 profile_id=self.profiles[client.profile], |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1088 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1089 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1090 if with_items: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1091 stmt = stmt.options( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1092 joinedload(PubsubNode.items) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1093 ) |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1094 if with_subscriptions: |
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1095 stmt = stmt.options( |
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1096 joinedload(PubsubNode.subscriptions) |
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1097 ) |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1098 result = await session.execute(stmt) |
3862
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1099 ret = result.unique().scalar_one_or_none() |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1100 if ret is None and create: |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1101 # we auto-create the node |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1102 if create_kwargs is None: |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1103 create_kwargs = {} |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1104 try: |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1105 return await as_future(self.setPubsubNode( |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1106 client, service, name, **create_kwargs |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1107 )) |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1108 except IntegrityError as e: |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1109 if "unique" in str(e.orig).lower(): |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1110 # the node may already exist, if it has been created just after |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1111 # getPubsubNode above |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1112 log.debug("ignoring UNIQUE constraint error") |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1113 cached_node = await as_future(self.getPubsubNode( |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1114 client, |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1115 service, |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1116 name, |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1117 with_items=with_items, |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1118 with_subscriptions=with_subscriptions |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1119 )) |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1120 else: |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1121 raise e |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1122 else: |
100dd30244c6
core (memory/sqla): add argument to `getPubsubNode` to auto-create a node:
Goffi <goffi@goffi.org>
parents:
3813
diff
changeset
|
1123 return ret |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1124 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1125 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1126 async def setPubsubNode( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1127 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1128 client: SatXMPPEntity, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1129 service: jid.JID, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1130 name: str, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1131 analyser: Optional[str] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1132 type_: Optional[str] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1133 subtype: Optional[str] = None, |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1134 subscribed: bool = False, |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1135 ) -> PubsubNode: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1136 node = PubsubNode( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1137 profile_id=self.profiles[client.profile], |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1138 service=service, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1139 name=name, |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1140 subscribed=subscribed, |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1141 analyser=analyser, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1142 type_=type_, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1143 subtype=subtype, |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1144 subscriptions=[], |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1145 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1146 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1147 async with session.begin(): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1148 session.add(node) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1149 return node |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1150 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1151 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1152 async def updatePubsubNodeSyncState( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1153 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1154 node: PubsubNode, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1155 state: SyncState |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1156 ) -> None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1157 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1158 async with session.begin(): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1159 await session.execute( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1160 update(PubsubNode) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1161 .filter_by(id=node.id) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1162 .values( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1163 sync_state=state, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1164 sync_state_updated=time.time(), |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1165 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1166 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1167 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1168 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1169 async def deletePubsubNode( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1170 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1171 profiles: Optional[List[str]], |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1172 services: Optional[List[jid.JID]], |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1173 names: Optional[List[str]] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1174 ) -> None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1175 """Delete items cached for a node |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1176 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1177 @param profiles: profile names from which nodes must be deleted. |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1178 None to remove nodes from ALL profiles |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1179 @param services: JIDs of pubsub services from which nodes must be deleted. |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1180 None to remove nodes from ALL services |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1181 @param names: names of nodes which must be deleted. |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1182 None to remove ALL nodes whatever is their names |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1183 """ |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1184 stmt = delete(PubsubNode) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1185 if profiles is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1186 stmt = stmt.where( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1187 PubsubNode.profile.in_( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1188 [self.profiles[p] for p in profiles] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1189 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1190 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1191 if services is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1192 stmt = stmt.where(PubsubNode.service.in_(services)) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1193 if names is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1194 stmt = stmt.where(PubsubNode.name.in_(names)) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1195 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1196 await session.execute(stmt) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1197 await session.commit() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1198 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1199 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1200 async def cachePubsubItems( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1201 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1202 client: SatXMPPEntity, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1203 node: PubsubNode, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1204 items: List[domish.Element], |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1205 parsed_items: Optional[List[dict]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1206 ) -> None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1207 """Add items to database, using an upsert taking care of "updated" field""" |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1208 if parsed_items is not None and len(items) != len(parsed_items): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1209 raise exceptions.InternalError( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1210 "parsed_items must have the same lenght as items" |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1211 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1212 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1213 async with session.begin(): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1214 for idx, item in enumerate(items): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1215 parsed = parsed_items[idx] if parsed_items else None |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1216 stmt = insert(PubsubItem).values( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1217 node_id = node.id, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1218 name = item["id"], |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1219 data = item, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1220 parsed = parsed, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1221 ).on_conflict_do_update( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1222 index_elements=(PubsubItem.node_id, PubsubItem.name), |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1223 set_={ |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1224 PubsubItem.data: item, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1225 PubsubItem.parsed: parsed, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1226 PubsubItem.updated: now() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1227 } |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1228 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1229 await session.execute(stmt) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1230 await session.commit() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1231 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1232 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1233 async def deletePubsubItems( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1234 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1235 node: PubsubNode, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1236 items_names: Optional[List[str]] = None |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1237 ) -> None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1238 """Delete items cached for a node |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1239 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1240 @param node: node from which items must be deleted |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1241 @param items_names: names of items to delete |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1242 if None, ALL items will be deleted |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1243 """ |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1244 stmt = delete(PubsubItem) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1245 if node is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1246 if isinstance(node, list): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1247 stmt = stmt.where(PubsubItem.node_id.in_([n.id for n in node])) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1248 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1249 stmt = stmt.filter_by(node_id=node.id) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1250 if items_names is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1251 stmt = stmt.where(PubsubItem.name.in_(items_names)) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1252 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1253 await session.execute(stmt) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1254 await session.commit() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1255 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1256 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1257 async def purgePubsubItems( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1258 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1259 services: Optional[List[jid.JID]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1260 names: Optional[List[str]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1261 types: Optional[List[str]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1262 subtypes: Optional[List[str]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1263 profiles: Optional[List[str]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1264 created_before: Optional[datetime] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1265 updated_before: Optional[datetime] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1266 ) -> None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1267 """Delete items cached for a node |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1268 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1269 @param node: node from which items must be deleted |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1270 @param items_names: names of items to delete |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1271 if None, ALL items will be deleted |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1272 """ |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1273 stmt = delete(PubsubItem) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1274 node_fields = { |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1275 "service": services, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1276 "name": names, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1277 "type_": types, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1278 "subtype": subtypes, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1279 } |
3744
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1280 if profiles is not None: |
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1281 node_fields["profile_id"] = [self.profiles[p] for p in profiles] |
658ddbabaf36
core (memory/sqla): new table/mapping to handle Pubsub node subscriptions:
Goffi <goffi@goffi.org>
parents:
3720
diff
changeset
|
1282 |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1283 if any(x is not None for x in node_fields.values()): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1284 sub_q = select(PubsubNode.id) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1285 for col, values in node_fields.items(): |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1286 if values is None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1287 continue |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1288 sub_q = sub_q.where(getattr(PubsubNode, col).in_(values)) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1289 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1290 stmt |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1291 .where(PubsubItem.node_id.in_(sub_q)) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1292 .execution_options(synchronize_session=False) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1293 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1294 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1295 if created_before is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1296 stmt = stmt.where(PubsubItem.created < created_before) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1297 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1298 if updated_before is not None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1299 stmt = stmt.where(PubsubItem.updated < updated_before) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1300 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1301 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1302 await session.execute(stmt) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1303 await session.commit() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1304 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1305 @aio |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1306 async def getItems( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1307 self, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1308 node: PubsubNode, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1309 max_items: Optional[int] = None, |
3753
10b71e3526bd
core (memory/sqla): add attribute to filter on `item_ids` in `getItems`
Goffi <goffi@goffi.org>
parents:
3744
diff
changeset
|
1310 item_ids: Optional[list[str]] = None, |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1311 before: Optional[str] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1312 after: Optional[str] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1313 from_index: Optional[int] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1314 order_by: Optional[List[str]] = None, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1315 desc: bool = True, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1316 force_rsm: bool = False, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1317 ) -> Tuple[List[PubsubItem], dict]: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1318 """Get Pubsub Items from cache |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1319 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1320 @param node: retrieve items from this node (must be synchronised) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1321 @param max_items: maximum number of items to retrieve |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1322 @param before: get items which are before the item with this name in given order |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1323 empty string is not managed here, use desc order to reproduce RSM |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1324 behaviour. |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1325 @param after: get items which are after the item with this name in given order |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1326 @param from_index: get items with item index (as defined in RSM spec) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1327 starting from this number |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1328 @param order_by: sorting order of items (one of C.ORDER_BY_*) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1329 @param desc: direction or ordering |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1330 @param force_rsm: if True, force the use of RSM worklow. |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1331 RSM workflow is automatically used if any of before, after or |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1332 from_index is used, but if only RSM max_items is used, it won't be |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1333 used by default. This parameter let's use RSM workflow in this |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1334 case. Note that in addition to RSM metadata, the result will not be |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1335 the same (max_items without RSM will returns most recent items, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1336 i.e. last items in modification order, while max_items with RSM |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1337 will return the oldest ones (i.e. first items in modification |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1338 order). |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1339 to be used when max_items is used from RSM |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1340 """ |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1341 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1342 metadata = { |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1343 "service": node.service, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1344 "node": node.name, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1345 "uri": uri.buildXMPPUri( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1346 "pubsub", |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1347 path=node.service.full(), |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1348 node=node.name, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1349 ), |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1350 } |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1351 if max_items is None: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1352 max_items = 20 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1353 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1354 use_rsm = any((before, after, from_index is not None)) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1355 if force_rsm and not use_rsm: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1356 # |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1357 use_rsm = True |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1358 from_index = 0 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1359 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1360 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1361 select(PubsubItem) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1362 .filter_by(node_id=node.id) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1363 .limit(max_items) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1364 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1365 |
3753
10b71e3526bd
core (memory/sqla): add attribute to filter on `item_ids` in `getItems`
Goffi <goffi@goffi.org>
parents:
3744
diff
changeset
|
1366 if item_ids is not None: |
10b71e3526bd
core (memory/sqla): add attribute to filter on `item_ids` in `getItems`
Goffi <goffi@goffi.org>
parents:
3744
diff
changeset
|
1367 stmt = stmt.where(PubsubItem.name.in_(item_ids)) |
10b71e3526bd
core (memory/sqla): add attribute to filter on `item_ids` in `getItems`
Goffi <goffi@goffi.org>
parents:
3744
diff
changeset
|
1368 |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1369 if not order_by: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1370 order_by = [C.ORDER_BY_MODIFICATION] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1371 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1372 order = [] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1373 for order_type in order_by: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1374 if order_type == C.ORDER_BY_MODIFICATION: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1375 if desc: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1376 order.extend((PubsubItem.updated.desc(), PubsubItem.id.desc())) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1377 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1378 order.extend((PubsubItem.updated.asc(), PubsubItem.id.asc())) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1379 elif order_type == C.ORDER_BY_CREATION: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1380 if desc: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1381 order.append(PubsubItem.id.desc()) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1382 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1383 order.append(PubsubItem.id.asc()) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1384 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1385 raise exceptions.InternalError(f"Unknown order type {order_type!r}") |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1386 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1387 stmt = stmt.order_by(*order) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1388 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1389 if use_rsm: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1390 # CTE to have result row numbers |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1391 row_num_q = select( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1392 PubsubItem.id, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1393 PubsubItem.name, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1394 # row_number starts from 1, but RSM index must start from 0 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1395 (func.row_number().over(order_by=order)-1).label("item_index") |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1396 ).filter_by(node_id=node.id) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1397 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1398 row_num_cte = row_num_q.cte() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1399 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1400 if max_items > 0: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1401 # as we can't simply use PubsubItem.id when we order by modification, |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1402 # we need to use row number |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1403 item_name = before or after |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1404 row_num_limit_q = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1405 select(row_num_cte.c.item_index) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1406 .where(row_num_cte.c.name==item_name) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1407 ).scalar_subquery() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1408 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1409 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1410 select(row_num_cte.c.item_index, PubsubItem) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1411 .join(row_num_cte, PubsubItem.id == row_num_cte.c.id) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1412 .limit(max_items) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1413 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1414 if before: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1415 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1416 stmt |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1417 .where(row_num_cte.c.item_index<row_num_limit_q) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1418 .order_by(row_num_cte.c.item_index.desc()) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1419 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1420 elif after: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1421 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1422 stmt |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1423 .where(row_num_cte.c.item_index>row_num_limit_q) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1424 .order_by(row_num_cte.c.item_index.asc()) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1425 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1426 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1427 stmt = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1428 stmt |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1429 .where(row_num_cte.c.item_index>=from_index) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1430 .order_by(row_num_cte.c.item_index.asc()) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1431 ) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1432 # from_index is used |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1433 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1434 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1435 if max_items == 0: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1436 items = result = [] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1437 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1438 result = await session.execute(stmt) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1439 result = result.all() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1440 if before: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1441 result.reverse() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1442 items = [row[-1] for row in result] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1443 rows_count = ( |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1444 await session.execute(row_num_q.with_only_columns(count())) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1445 ).scalar_one() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1446 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1447 try: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1448 index = result[0][0] |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1449 except IndexError: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1450 index = None |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1451 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1452 try: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1453 first = result[0][1].name |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1454 except IndexError: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1455 first = None |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1456 last = None |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1457 else: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1458 last = result[-1][1].name |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1459 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1460 metadata["rsm"] = { |
3719
cf930bb282ac
memory (sqla): don't set keys with None as value for RSM in `getItems`
Goffi <goffi@goffi.org>
parents:
3673
diff
changeset
|
1461 k: v for k, v in { |
cf930bb282ac
memory (sqla): don't set keys with None as value for RSM in `getItems`
Goffi <goffi@goffi.org>
parents:
3673
diff
changeset
|
1462 "index": index, |
cf930bb282ac
memory (sqla): don't set keys with None as value for RSM in `getItems`
Goffi <goffi@goffi.org>
parents:
3673
diff
changeset
|
1463 "count": rows_count, |
cf930bb282ac
memory (sqla): don't set keys with None as value for RSM in `getItems`
Goffi <goffi@goffi.org>
parents:
3673
diff
changeset
|
1464 "first": first, |
cf930bb282ac
memory (sqla): don't set keys with None as value for RSM in `getItems`
Goffi <goffi@goffi.org>
parents:
3673
diff
changeset
|
1465 "last": last, |
cf930bb282ac
memory (sqla): don't set keys with None as value for RSM in `getItems`
Goffi <goffi@goffi.org>
parents:
3673
diff
changeset
|
1466 }.items() if v is not None |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1467 } |
3720
40a6374fcd44
memory (sqla): fix `complete` setting when `index` is `None` in `getItems`
Goffi <goffi@goffi.org>
parents:
3719
diff
changeset
|
1468 metadata["complete"] = (index or 0) + len(result) == rows_count |
3595
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1469 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1470 return items, metadata |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1471 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1472 async with self.session() as session: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1473 result = await session.execute(stmt) |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1474 |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1475 result = result.scalars().all() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1476 if desc: |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1477 result.reverse() |
7510648e8e3a
core (memory/sqla): methods to manipulate pubsub tables
Goffi <goffi@goffi.org>
parents:
3583
diff
changeset
|
1478 return result, metadata |
3664
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1479 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1480 def _getSqlitePath( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1481 self, |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1482 path: List[Union[str, int]] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1483 ) -> str: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1484 """generate path suitable to query JSON element with SQLite""" |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1485 return f"${''.join(f'[{p}]' if isinstance(p, int) else f'.{p}' for p in path)}" |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1486 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1487 @aio |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1488 async def searchPubsubItems( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1489 self, |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1490 query: dict, |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1491 ) -> Tuple[List[PubsubItem]]: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1492 """Search for pubsub items in cache |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1493 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1494 @param query: search terms. Keys can be: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1495 :fts (str): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1496 Full-Text Search query. Currently SQLite FT5 engine is used, its query |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1497 syntax can be used, see `FTS5 Query documentation |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1498 <https://sqlite.org/fts5.html#full_text_query_syntax>`_ |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1499 :profiles (list[str]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1500 filter on nodes linked to those profiles |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1501 :nodes (list[str]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1502 filter on nodes with those names |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1503 :services (list[jid.JID]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1504 filter on nodes from those services |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1505 :types (list[str|None]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1506 filter on nodes with those types. None can be used to filter on nodes with |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1507 no type set |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1508 :subtypes (list[str|None]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1509 filter on nodes with those subtypes. None can be used to filter on nodes with |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1510 no subtype set |
3754
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1511 :names (list[str]): |
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1512 filter on items with those names |
3664
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1513 :parsed (list[dict]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1514 Filter on a parsed data field. The dict must contain 3 keys: ``path`` |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1515 which is a list of str or int giving the path to the field of interest |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1516 (str for a dict key, int for a list index), ``operator`` with indicate the |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1517 operator to use to check the condition, and ``value`` which depends of |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1518 field type and operator. |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1519 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1520 See documentation for details on operators (it's currently explained at |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1521 ``doc/libervia-cli/pubsub_cache.rst`` in ``search`` command |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1522 documentation). |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1523 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1524 :order-by (list[dict]): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1525 Indicates how to order results. The dict can contain either a ``order`` |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1526 for a well-know order or a ``path`` for a parsed data field path |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1527 (``order`` and ``path`` can't be used at the same time), an an optional |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1528 ``direction`` which can be ``asc`` or ``desc``. See documentation for |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1529 details on well-known orders (it's currently explained at |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1530 ``doc/libervia-cli/pubsub_cache.rst`` in ``search`` command |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1531 documentation). |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1532 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1533 :index (int): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1534 starting index of items to return from the query result. It's translated |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1535 to SQL's OFFSET |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1536 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1537 :limit (int): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1538 maximum number of items to return. It's translated to SQL's LIMIT. |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1539 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1540 @result: found items (the ``node`` attribute will be filled with suitable |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1541 PubsubNode) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1542 """ |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1543 # TODO: FTS and parsed data filters use SQLite specific syntax |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1544 # when other DB engines will be used, this will have to be adapted |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1545 stmt = select(PubsubItem) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1546 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1547 # Full-Text Search |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1548 fts = query.get("fts") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1549 if fts: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1550 fts_select = text( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1551 "SELECT rowid, rank FROM pubsub_items_fts(:fts_query)" |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1552 ).bindparams(fts_query=fts).columns(rowid=Integer).subquery() |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1553 stmt = ( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1554 stmt |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1555 .select_from(fts_select) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1556 .outerjoin(PubsubItem, fts_select.c.rowid == PubsubItem.id) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1557 ) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1558 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1559 # node related filters |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1560 profiles = query.get("profiles") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1561 if (profiles |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1562 or any(query.get(k) for k in ("nodes", "services", "types", "subtypes")) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1563 ): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1564 stmt = stmt.join(PubsubNode).options(contains_eager(PubsubItem.node)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1565 if profiles: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1566 try: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1567 stmt = stmt.where( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1568 PubsubNode.profile_id.in_(self.profiles[p] for p in profiles) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1569 ) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1570 except KeyError as e: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1571 raise exceptions.ProfileUnknownError( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1572 f"This profile doesn't exist: {e.args[0]!r}" |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1573 ) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1574 for key, attr in ( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1575 ("nodes", "name"), |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1576 ("services", "service"), |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1577 ("types", "type_"), |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1578 ("subtypes", "subtype") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1579 ): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1580 value = query.get(key) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1581 if not value: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1582 continue |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1583 if key in ("types", "subtypes") and None in value: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1584 # NULL can't be used with SQL's IN, so we have to add a condition with |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1585 # IS NULL, and use a OR if there are other values to check |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1586 value.remove(None) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1587 condition = getattr(PubsubNode, attr).is_(None) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1588 if value: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1589 condition = or_( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1590 getattr(PubsubNode, attr).in_(value), |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1591 condition |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1592 ) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1593 else: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1594 condition = getattr(PubsubNode, attr).in_(value) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1595 stmt = stmt.where(condition) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1596 else: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1597 stmt = stmt.options(selectinload(PubsubItem.node)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1598 |
3754
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1599 # names |
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1600 names = query.get("names") |
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1601 if names: |
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1602 stmt = stmt.where(PubsubItem.name.in_(names)) |
af485e8afe03
core (memory/sqla): `searchPubsubItems` can now filter on item names
Goffi <goffi@goffi.org>
parents:
3753
diff
changeset
|
1603 |
3664
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1604 # parsed data filters |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1605 parsed = query.get("parsed", []) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1606 for filter_ in parsed: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1607 try: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1608 path = filter_["path"] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1609 operator = filter_["op"] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1610 value = filter_["value"] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1611 except KeyError as e: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1612 raise ValueError( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1613 f'missing mandatory key {e.args[0]!r} in "parsed" filter' |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1614 ) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1615 try: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1616 op_attr = OP_MAP[operator] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1617 except KeyError: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1618 raise ValueError(f"invalid operator: {operator!r}") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1619 sqlite_path = self._getSqlitePath(path) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1620 if operator in ("overlap", "ioverlap", "disjoint", "idisjoint"): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1621 col = literal_column("json_each.value") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1622 if operator[0] == "i": |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1623 col = func.lower(col) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1624 value = [str(v).lower() for v in value] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1625 condition = ( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1626 select(1) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1627 .select_from(func.json_each(PubsubItem.parsed, sqlite_path)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1628 .where(col.in_(value)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1629 ).scalar_subquery() |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1630 if operator in ("disjoint", "idisjoint"): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1631 condition = condition.is_(None) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1632 stmt = stmt.where(condition) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1633 elif operator == "between": |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1634 try: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1635 left, right = value |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1636 except (ValueError, TypeError): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1637 raise ValueError(_( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1638 "invalid value for \"between\" filter, you must use a 2 items " |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1639 "array: {value!r}" |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1640 ).format(value=value)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1641 col = func.json_extract(PubsubItem.parsed, sqlite_path) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1642 stmt = stmt.where(col.between(left, right)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1643 else: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1644 # we use func.json_extract instead of generic JSON way because SQLAlchemy |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1645 # add a JSON_QUOTE to the value, and we want SQL value |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1646 col = func.json_extract(PubsubItem.parsed, sqlite_path) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1647 stmt = stmt.where(getattr(col, op_attr)(value)) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1648 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1649 # order |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1650 order_by = query.get("order-by") or [{"order": "creation"}] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1651 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1652 for order_data in order_by: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1653 order, path = order_data.get("order"), order_data.get("path") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1654 if order and path: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1655 raise ValueError(_( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1656 '"order" and "path" can\'t be used at the same time in ' |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1657 '"order-by" data' |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1658 )) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1659 if order: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1660 if order == "creation": |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1661 col = PubsubItem.id |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1662 elif order == "modification": |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1663 col = PubsubItem.updated |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1664 elif order == "item_id": |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1665 col = PubsubItem.name |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1666 elif order == "rank": |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1667 if not fts: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1668 raise ValueError( |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1669 "'rank' order can only be used with Full-Text Search (fts)" |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1670 ) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1671 col = literal_column("rank") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1672 else: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1673 raise NotImplementedError(f"Unknown {order!r} order") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1674 else: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1675 # we have a JSON path |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1676 # sqlite_path = self._getSqlitePath(path) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1677 col = PubsubItem.parsed[path] |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1678 direction = order_data.get("direction", "ASC").lower() |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1679 if not direction in ("asc", "desc"): |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1680 raise ValueError(f"Invalid order-by direction: {direction!r}") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1681 stmt = stmt.order_by(getattr(col, direction)()) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1682 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1683 # offset, limit |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1684 index = query.get("index") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1685 if index: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1686 stmt = stmt.offset(index) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1687 limit = query.get("limit") |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1688 if limit: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1689 stmt = stmt.limit(limit) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1690 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1691 async with self.session() as session: |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1692 result = await session.execute(stmt) |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1693 |
9ae6ec74face
memory (sqla): implement `searchPubsubItems`:
Goffi <goffi@goffi.org>
parents:
3638
diff
changeset
|
1694 return result.scalars().all() |