sqlmodel_crud_utils

480def bulk_upsert_mappings(
481    payload: list,
482    session_inst: Session,
483    model: type[SQLModel],
484    pk_fields: list[str] | None = None,
485):
486    """
487
488    :param payload:
489    :param session_inst:
490    :param model:
491    :param pk_fields:
492    :return:
493    """
494    if not pk_fields:
495        pk_fields = ["id"]
496    stmnt = upsert(model).values(payload)
497    stmnt = stmnt.on_conflict_do_update(
498        index_elements=[getattr(model, x) for x in pk_fields],
499        set_={k: getattr(stmnt.excluded, k) for k in payload[0].keys()},
500    )
501    session_inst.exec(stmnt)
502
503    results = session_inst.scalars(
504        stmnt.returning(model), execution_options={"populate_existing": True}
505    )
506
507    session_inst.commit()
508
509    return True, results.all()

443def delete_row(
444    id_str: str | int,
445    session_inst: Session,
446    model: type[SQLModel],
447    pk_field: str = "id",
448):
449    """
450
451    :param id_str:
452    :param session_inst:
453    :param model:
454    :param pk_field:
455    :return:
456    """
457    success = False
458    stmnt = select(model).where(getattr(model, pk_field) == id_str)
459    results = session_inst.exec(stmnt)
460
461    row = results.one_or_none()
462
463    if not row:
464        pass
465    else:
466        try:
467            session_inst.delete(row)
468            session_inst.commit()
469            success = True
470        except Exception as e:
471            logger.error(
472                f"Failed to delete data row. Please see error messages here: "
473                f"{type(e), e, e.args}"
474            )
475            session_inst.rollback()
476
477    return success

44def get_one_or_create(
45    session_inst: Session,
46    model: type[SQLModel],
47    create_method_kwargs: dict | None = None,
48    selectin: bool = False,
49    select_in_key: str | None = None,
50    **kwargs,
51):
52    """
53    This function either returns an existing data row from the database or
54    creates a new instance and saves it to the DB.
55
56    :param session_inst: Session
57    :param model: SQLModel ORM
58    :param create_method_kwargs: dict
59    :param selectin: bool
60    :param select_in_key: str | None
61    :param kwargs: keyword args
62    :return: Tuple[Row, bool]
63    """
64
65    def _get_entry(sqlmodel, **key_args):
66        stmnt = select(sqlmodel).filter_by(**key_args)
67        results = get_result_from_query(query=stmnt, session=session_inst)
68
69        if results:
70            if selectin and select_in_key:
71                stmnt = stmnt.options(
72                    selectinload(getattr(sqlmodel, select_in_key))
73                )
74                results = get_result_from_query(
75                    query=stmnt, session=session_inst
76                )
77            return results, True
78        else:
79            return results, False
80
81    results, exists = _get_entry(model, **kwargs)
82    if results:
83        return results, exists
84    else:
85        kwargs.update(create_method_kwargs or {})
86        created = model()
87        [setattr(created, k, v) for k, v in kwargs.items()]
88        session_inst.add(created)
89        session_inst.commit()
90        return created, False

23def get_result_from_query(query: SelectOfScalar, session: Session):
24    """
25    Processes an SQLModel query object and returns a singular result from the
26    return payload. If more than one row is returned, then only the first row is
27    returned. If no rows are available, then a null value is returned.
28
29    :param query: SelectOfScalar
30    :param session: Session
31
32    :return: Row
33    """
34    results = session.exec(query)
35    try:
36        results = results.one_or_none()
37    except MultipleResultsFound:
38        results = session.exec(query)
39        results = results.first()
40
41    return results

156def get_row(
157    id_str: str | int,
158    session_inst: Session,
159    model: type[SQLModel],
160    selectin: bool = False,
161    lazy: bool = False,
162    lazy_load_keys: list[str] | None = None,
163    select_in_keys: list[str] | None = None,
164    pk_field: str = "id",
165):
166    """
167
168    :param id_str:
169    :param session_inst:
170    :param model:
171    :param selectin:
172    :param lazy:
173    :param lazy_load_keys:
174    :param select_in_keys:
175    :param pk_field:
176    :return:
177    """
178    stmnt = select(model).where(getattr(model, pk_field) == id_str)
179    if selectin and select_in_keys:
180        if isinstance(select_in_keys, list) is False:
181            select_in_keys = [select_in_keys]
182
183        for key in select_in_keys:
184            stmnt = stmnt.options(selectinload(getattr(model, key)))
185    if lazy and lazy_load_keys:
186        if isinstance(lazy_load_keys, list) is False:
187            lazy_load_keys = [lazy_load_keys]
188        for key in lazy_load_keys:
189            stmnt = stmnt.options(lazyload(getattr(model, key)))
190    results = session_inst.exec(stmnt)
191
192    row = results.one_or_none()
193
194    if not row:
195        success = False
196    else:
197        success = True
198
199    return success, row

202def get_rows(
203    session_inst: Session,
204    model: type[SQLModel],
205    selectin: bool = False,
206    select_in_keys: list[str] | None = None,
207    lazy: bool = False,
208    lazy_load_keys: list[str] | None = None,
209    page_size: int = 100,
210    page: int = 1,
211    text_field: str | None = None,
212    stmnt: SelectOfScalar | None = None,
213    **kwargs,
214):
215    """
216
217    :param session_inst:
218    :param model:
219    :param selectin:
220    :param select_in_keys:
221    :param lazy:
222    :param lazy_load_keys:
223    :param page_size:
224    :param page:
225    :param text_field:
226    :param stmnt:
227    :param kwargs:
228    :return:
229    """
230    # Inside get_rows (sync and async versions)
231
232    # ... existing code ...
233    if stmnt is None:
234        stmnt = select(model)
235        if kwargs:
236            # Separate special filter keys from exact match keys
237            exact_match_kwargs = {}
238            special_filters = {}
239
240            keys_to_process = list(kwargs.keys())  # Iterate over a copy
241
242            for key in keys_to_process:
243                val = kwargs[key]
244                if "__like" in key:
245                    model_key = key.replace("__like", "")
246                    special_filters[key] = (
247                        getattr(model, model_key).like,
248                        f"%{val}%",
249                    )  # Adapt for like
250                elif "__gte" in key:
251                    model_key = key.replace("__gte", "")
252                    parsed_val = (
253                        date_parse(val)
254                        if "date" in key
255                        and isinstance(val, str)
256                        and is_date(val, fuzzy=False)
257                        else (
258                            int(val)
259                            if isinstance(val, str) and val.isdigit()
260                            else val
261                        )
262                    )
263                    special_filters[key] = (
264                        getattr(model, model_key).__ge__,
265                        parsed_val,
266                    )
267                elif "__lte" in key:
268                    model_key = key.replace("__lte", "")
269                    parsed_val = (
270                        date_parse(val)
271                        if "date" in key
272                        and isinstance(val, str)
273                        and is_date(val, fuzzy=False)
274                        else (
275                            int(val)
276                            if isinstance(val, str) and val.isdigit()
277                            else val
278                        )
279                    )
280                    special_filters[key] = (
281                        getattr(model, model_key).__le__,
282                        parsed_val,
283                    )
284                elif "__gt" in key:  # Add __gt if needed
285                    model_key = key.replace("__gt", "")
286                    parsed_val = (
287                        date_parse(val)
288                        if "date" in key
289                        and isinstance(val, str)
290                        and is_date(val, fuzzy=False)
291                        else (
292                            int(val)
293                            if isinstance(val, str) and val.isdigit()
294                            else val
295                        )
296                    )
297                    special_filters[key] = (
298                        getattr(model, model_key).__gt__,
299                        parsed_val,
300                    )
301                elif "__lt" in key:  # Add __lt if needed
302                    model_key = key.replace("__lt", "")
303                    parsed_val = (
304                        date_parse(val)
305                        if "date" in key
306                        and isinstance(val, str)
307                        and is_date(val, fuzzy=False)
308                        else (
309                            int(val)
310                            if isinstance(val, str) and val.isdigit()
311                            else val
312                        )
313                    )
314                    special_filters[key] = (
315                        getattr(model, model_key).__lt__,
316                        parsed_val,
317                    )
318                elif "__in" in key:  # Add __in if needed
319                    model_key = key.replace("__in", "")
320                    if isinstance(val, list):
321                        special_filters[key] = (
322                            getattr(model, model_key).in_,
323                            val,
324                        )
325                    else:
326                        logger.warning(
327                            f"Value for __in filter '{key}' is not a list, "
328                            f"skipping."
329                        )
330                elif key not in ("sort_desc", "sort_field") and (
331                    not text_field or key != text_field
332                ):
333                    # Collect keys for filter_by, excluding sort/text search
334                    # keys
335                    exact_match_kwargs[key] = val
336
337            # Apply special filters using filter()
338            for _filter_key, (
339                filter_method,
340                filter_value,
341            ) in special_filters.items():
342                stmnt = stmnt.filter(filter_method(filter_value))
343
344            # Apply sorting
345            sort_desc = kwargs.get("sort_desc")
346            sort_field = kwargs.get("sort_field")
347            if sort_field:
348                sort_attr = getattr(model, sort_field)
349                stmnt = stmnt.order_by(
350                    sort_attr.desc() if sort_desc else sort_attr
351                )
352
353            # Apply text search if applicable (assuming .match() is correct)
354            if text_field and text_field in kwargs:
355                search_val = kwargs[text_field]
356                stmnt = stmnt.where(
357                    getattr(model, text_field).match(search_val)
358                )
359                # Remove from exact_match_kwargs if it ended up there
360                exact_match_kwargs.pop(text_field, None)
361
362            # Apply exact matches using filter_by()
363            if exact_match_kwargs:
364                stmnt = stmnt.filter_by(**exact_match_kwargs)
365
366        # Apply relationship loading options (Check if key is a relationship
367        # first - simplified check)
368        if selectin and select_in_keys:
369            for key in select_in_keys:
370                # Basic check: Does the attribute exist and is it likely a
371                # relationship?
372                # A more robust check might involve inspecting
373                # model.__sqlmodel_relationships__
374                attr = getattr(model, key, None)
375                if (
376                    attr is not None
377                    and hasattr(attr, "property")
378                    and hasattr(attr.property, "mapper")
379                ):
380                    stmnt = stmnt.options(selectinload(attr))
381                else:
382                    logger.warning(
383                        f"Skipping selectinload for non-relationship "
384                        f"attribute '{key}' on model {model.__name__}"
385                    )
386
387        if lazy and lazy_load_keys:
388            for key in lazy_load_keys:
389                attr = getattr(model, key, None)
390                if (
391                    attr is not None
392                    and hasattr(attr, "property")
393                    and hasattr(attr.property, "mapper")
394                ):
395                    stmnt = stmnt.options(lazyload(attr))
396                else:
397                    logger.warning(
398                        f"Skipping lazyload for non-relationship attribute  "
399                        f"'{key}' on model {model.__name__}"
400                    )
401
402    # Apply pagination
403    stmnt = stmnt.offset((page - 1) * page_size).limit(
404        page_size
405    )  # Corrected offset calculation
406
407    _result = session_inst.exec(stmnt)
408    results = _result.all()
409    success = True if len(results) > 0 else False
410
411    return success, results

414def get_rows_within_id_list(
415    id_str_list: list[str | int],
416    session_inst: Session,
417    model: type[SQLModel],
418    pk_field: str = "id",
419):
420    """
421    Retrieves rows from the database whose primary key is within the provided
422    list.
423
424    :param id_str_list: List of primary key values to fetch.
425    :param session_inst: SQLAlchemy Session instance.
426    :param model: SQLModel class representing the table.
427    :param pk_field: Name of the primary key field (default: "id").
428    :return: Tuple[bool, list[SQLModel]]: A tuple containing a success flag
429             (True if rows were found, False otherwise) and a list of the
430             found model instances.
431    """
432    if not id_str_list:  # Handle empty input list
433        return False, []
434
435    stmnt = select(model).where(getattr(model, pk_field).in_(id_str_list))
436    results = session_inst.exec(stmnt).all()  # Fetch all results into a list
437
438    success = len(results) > 0  # Success is true only if results were found
439
440    return success, results

117def insert_data_rows(data_rows, session_inst: Session):
118    """
119
120    :param data_rows:
121    :param session_inst:
122    :return:
123    """
124    try:
125        session_inst.add_all(data_rows)
126        session_inst.commit()
127
128        return True, data_rows
129
130    except Exception as e:
131        logger.error(
132            f"Writing data rows to table failed. See error message: "
133            f"{type(e), e, e.args}"
134        )
135        logger.info(
136            "Attempting to write individual entries. This can be a "
137            "bit taxing, so please consider your payload to the DB"
138        )
139
140        session_inst.rollback()
141        processed_rows, failed_rows = [], []
142        for row in data_rows:
143            success, processed_row = write_row(row, session_inst=session_inst)
144            if not success:
145                failed_rows.append(row)
146            else:
147                processed_rows.append(row)
148
149        if processed_rows:
150            status = True
151        else:
152            status = (False,)
153        return status, {"success": processed_rows, "failed": failed_rows}

512def update_row(
513    id_str: int | str,
514    data: dict,
515    session_inst: Session,
516    model: type[SQLModel],
517    pk_field: str = "id",
518):
519    """
520
521    :param id_str:
522    :param data:
523    :param session_inst:
524    :param model:
525    :param pk_field:
526    :return:
527    """
528    success = False
529    stmnt = select(model).where(getattr(model, pk_field) == id_str)
530    results = session_inst.exec(stmnt)
531
532    row = results.one_or_none()
533
534    if row:
535        [setattr(row, k, v) for k, v in data.items()]
536        try:
537            session_inst.add(row)
538            session_inst.commit()
539            success = True
540        except Exception as e:
541            session_inst.rollback()
542            logger.error(
543                f"Updating the data row failed. See error messages: "
544                f"{type(e), e, e.args}"
545            )
546        return success, row
547    else:
548        return success, None

 93def write_row(data_row: SQLModel, session_inst: Session):
 94    """
 95    Writes a new instance of an SQLModel ORM model to the database, with an
 96    exception catch that rolls back the session in the event of failure.
 97
 98    :param data_row: SQLModel
 99    :param session_inst: Session
100    :return: Tuple[bool, ScalarResult]
101    """
102    try:
103        session_inst.add(data_row)
104        session_inst.commit()
105
106        return True, data_row
107    except Exception as e:
108        session_inst.rollback()
109        logger.error(
110            f"Writing data row to table failed. See error message: "
111            f"{type(e), e, e.args}"
112        )
113
114        return False, None

479async def bulk_upsert_mappings(
480    payload: list,
481    session_inst: AsyncSession,
482    model: type[SQLModel],
483    pk_fields: list[str] | None = None,
484):
485    """
486
487    :param payload:
488    :param session_inst:
489    :param model:
490    :param pk_fields:
491    :return:
492    """
493    if not pk_fields:
494        pk_fields = ["id"]
495    stmnt = upsert(model).values(payload)
496    stmnt = stmnt.on_conflict_do_update(
497        index_elements=[getattr(model, x) for x in pk_fields],
498        set_={k: getattr(stmnt.excluded, k) for k in payload[0].keys()},
499    )
500    await session_inst.exec(stmnt)
501
502    results = await session_inst.scalars(
503        stmnt.returning(model), execution_options={"populate_existing": True}
504    )
505
506    await session_inst.commit()
507
508    return True, results.all()

442async def delete_row(
443    id_str: str | int,
444    session_inst: AsyncSession,
445    model: type[SQLModel],
446    pk_field: str = "id",
447):
448    """
449
450    :param id_str:
451    :param session_inst:
452    :param model:
453    :param pk_field:
454    :return:
455    """
456    success = False
457    stmnt = select(model).where(getattr(model, pk_field) == id_str)
458    results = await session_inst.exec(stmnt)
459
460    row = results.one_or_none()
461
462    if not row:
463        pass
464    else:
465        try:
466            await session_inst.delete(row)
467            await session_inst.commit()
468            success = True
469        except Exception as e:
470            logger.error(
471                f"Failed to delete data row. Please see error messages here: "
472                f"{type(e), e, e.args}"
473            )
474            await session_inst.rollback()
475
476    return success

45async def get_one_or_create(
46    session_inst: AsyncSession,
47    model: type[SQLModel],
48    create_method_kwargs: dict | None = None,
49    selectin: bool = False,
50    select_in_key: str | None = None,
51    **kwargs,
52):
53    """
54    This function either returns an existing data row from the database or
55    creates a new instance and saves it to the DB.
56
57    :param session_inst: AsyncSession
58    :param model: SQLModel ORM
59    :param create_method_kwargs: dict
60    :param selectin: bool
61    :param select_in_key: str | None
62    :param kwargs: keyword args
63    :return: Tuple[Row, bool]
64    """
65
66    async def _get_entry(sqlmodel, **key_args):
67        stmnt = select(sqlmodel).filter_by(**key_args)
68        results = await get_result_from_query(query=stmnt, session=session_inst)
69
70        if results:
71            if selectin and select_in_key:
72                stmnt = stmnt.options(
73                    selectinload(getattr(sqlmodel, select_in_key))
74                )
75                results = await get_result_from_query(
76                    query=stmnt, session=session_inst
77                )
78            return results, True
79        else:
80            return results, False
81
82    results, exists = await _get_entry(model, **kwargs)
83    if results:
84        return results, exists
85    else:
86        kwargs.update(create_method_kwargs or {})
87        created = model()
88        [setattr(created, k, v) for k, v in kwargs.items()]
89        session_inst.add(created)
90        await session_inst.commit()
91        return created, False

24async def get_result_from_query(query: SelectOfScalar, session: AsyncSession):
25    """
26    Processes an SQLModel query object and returns a singular result from the
27    return payload. If more than one row is returned, then only the first row is
28    returned. If no rows are available, then a null value is returned.
29
30    :param query: SelectOfScalar
31    :param session: AsyncSession
32
33    :return: Row
34    """
35    results = await session.exec(query)
36    try:
37        results = results.one_or_none()
38    except MultipleResultsFound:
39        results = await session.exec(query)
40        results = results.first()
41
42    return results

159async def get_row(
160    id_str: str | int,
161    session_inst: AsyncSession,
162    model: type[SQLModel],
163    selectin: bool = False,
164    select_in_keys: list[str] | None = None,
165    lazy: bool = False,
166    lazy_load_keys: list[str] | None = None,
167    pk_field: str = "id",
168):
169    """
170
171    :param id_str:
172    :param session_inst:
173    :param model:
174    :param selectin:
175    :param select_in_keys:
176    :param lazy:
177    :param lazy_load_keys:
178    :param pk_field:
179    :return:
180    """
181    stmnt = select(model).where(getattr(model, pk_field) == id_str)
182    if selectin and select_in_keys:
183        if isinstance(select_in_keys, list) is False:
184            select_in_keys = [select_in_keys]
185
186        for key in select_in_keys:
187            stmnt = stmnt.options(selectinload(getattr(model, key)))
188    if lazy and lazy_load_keys:
189        if isinstance(lazy_load_keys, list) is False:
190            lazy_load_keys = [lazy_load_keys]
191        for key in lazy_load_keys:
192            stmnt = stmnt.options(lazyload(getattr(model, key)))
193    results = await session_inst.exec(stmnt)
194
195    row = results.one_or_none()
196
197    if not row:
198        success = False
199    else:
200        success = True
201
202    return success, row

205async def get_rows(
206    session_inst: AsyncSession,
207    model: type[SQLModel],
208    selectin: bool = False,
209    select_in_keys: list[str] | None = None,
210    lazy: bool = False,
211    lazy_load_keys: list[str] | None = None,
212    page_size: int = 100,
213    page: int = 1,
214    text_field: str | None = None,
215    stmnt: SelectOfScalar | None = None,
216    **kwargs,
217):
218    """
219
220    :param session_inst:
221    :param model:
222    :param selectin:
223    :param select_in_keys:
224    :param lazy:
225    :param lazy_load_keys:
226    :param page_size:
227    :param page:
228    :param text_field:
229    :param stmnt:
230    :param kwargs:
231    :return:
232    """
233    # kwargs = {k: v for k, v in kwargs.items() if v}
234    # Inside get_rows (sync and async versions)
235
236    # ... existing code ...
237    if stmnt is None:
238        stmnt = select(model)
239        if kwargs:
240            # Separate special filter keys from exact match keys
241            exact_match_kwargs = {}
242            special_filters = {}
243
244            keys_to_process = list(kwargs.keys())  # Iterate over a copy
245
246            for key in keys_to_process:
247                val = kwargs[key]
248                if "__like" in key:
249                    model_key = key.replace("__like", "")
250                    special_filters[key] = (
251                        getattr(model, model_key).like,
252                        f"%{val}%",
253                    )  # Adapt for like
254                elif "__gte" in key:
255                    model_key = key.replace("__gte", "")
256                    parsed_val = (
257                        date_parse(val)
258                        if "date" in key
259                        and isinstance(val, str)
260                        and is_date(val, fuzzy=False)
261                        else (
262                            int(val)
263                            if isinstance(val, str) and val.isdigit()
264                            else val
265                        )
266                    )
267                    special_filters[key] = (
268                        getattr(model, model_key).__ge__,
269                        parsed_val,
270                    )
271                elif "__lte" in key:
272                    model_key = key.replace("__lte", "")
273                    parsed_val = (
274                        date_parse(val)
275                        if "date" in key
276                        and isinstance(val, str)
277                        and is_date(val, fuzzy=False)
278                        else (
279                            int(val)
280                            if isinstance(val, str) and val.isdigit()
281                            else val
282                        )
283                    )
284                    special_filters[key] = (
285                        getattr(model, model_key).__le__,
286                        parsed_val,
287                    )
288                elif "__gt" in key:  # Add __gt if needed
289                    model_key = key.replace("__gt", "")
290                    parsed_val = (
291                        date_parse(val)
292                        if "date" in key
293                        and isinstance(val, str)
294                        and is_date(val, fuzzy=False)
295                        else (
296                            int(val)
297                            if isinstance(val, str) and val.isdigit()
298                            else val
299                        )
300                    )
301                    special_filters[key] = (
302                        getattr(model, model_key).__gt__,
303                        parsed_val,
304                    )
305                elif "__lt" in key:  # Add __lt if needed
306                    model_key = key.replace("__lt", "")
307                    parsed_val = (
308                        date_parse(val)
309                        if "date" in key
310                        and isinstance(val, str)
311                        and is_date(val, fuzzy=False)
312                        else (
313                            int(val)
314                            if isinstance(val, str) and val.isdigit()
315                            else val
316                        )
317                    )
318                    special_filters[key] = (
319                        getattr(model, model_key).__lt__,
320                        parsed_val,
321                    )
322                elif "__in" in key:  # Add __in if needed
323                    model_key = key.replace("__in", "")
324                    if isinstance(val, list):
325                        special_filters[key] = (
326                            getattr(model, model_key).in_,
327                            val,
328                        )
329                    else:
330                        logger.warning(
331                            f"Value for __in filter '{key}' is not a list, "
332                            f"skipping."
333                        )
334                elif key not in ("sort_desc", "sort_field") and (
335                    not text_field or key != text_field
336                ):
337                    # Collect keys for filter_by, excluding sort/text search
338                    # keys
339                    exact_match_kwargs[key] = val
340
341            # Apply special filters using filter()
342            for _filter_key, (
343                filter_method,
344                filter_value,
345            ) in special_filters.items():
346                stmnt = stmnt.filter(filter_method(filter_value))
347
348            # Apply sorting
349            sort_desc = kwargs.get("sort_desc")
350            sort_field = kwargs.get("sort_field")
351            if sort_field:
352                sort_attr = getattr(model, sort_field)
353                stmnt = stmnt.order_by(
354                    sort_attr.desc() if sort_desc else sort_attr
355                )
356
357            # Apply text search if applicable (assuming .match() is correct)
358            if text_field and text_field in kwargs:
359                search_val = kwargs[text_field]
360                stmnt = stmnt.where(
361                    getattr(model, text_field).match(search_val)
362                )
363                # Remove from exact_match_kwargs if it ended up there
364                exact_match_kwargs.pop(text_field, None)
365
366            # Apply exact matches using filter_by()
367            if exact_match_kwargs:
368                stmnt = stmnt.filter_by(**exact_match_kwargs)
369
370        # Apply relationship loading options (Check if key is a relationship
371        # first - simplified check)
372        if selectin and select_in_keys:
373            for key in select_in_keys:
374                # Basic check: Does the attribute exist and is it likely a
375                # relationship?
376                # A more robust check might involve inspecting
377                # model.__sqlmodel_relationships__
378                attr = getattr(model, key, None)
379                if (
380                    attr is not None
381                    and hasattr(attr, "property")
382                    and hasattr(attr.property, "mapper")
383                ):
384                    stmnt = stmnt.options(selectinload(attr))
385                else:
386                    logger.warning(
387                        f"Skipping selectinload for non-relationship "
388                        f"attribute '{key}' on model {model.__name__}"
389                    )
390
391        if lazy and lazy_load_keys:
392            for key in lazy_load_keys:
393                attr = getattr(model, key, None)
394                if (
395                    attr is not None
396                    and hasattr(attr, "property")
397                    and hasattr(attr.property, "mapper")
398                ):
399                    stmnt = stmnt.options(lazyload(attr))
400                else:
401                    logger.warning(
402                        f"Skipping lazyload for non-relationship attribute "
403                        f"'{key}' on model {model.__name__}"
404                    )
405
406    # Apply pagination
407    stmnt = stmnt.offset((page - 1) * page_size).limit(
408        page_size
409    )  # Corrected offset calculation
410    _result = await session_inst.exec(stmnt)
411    results = _result.all()
412    success = True if len(results) > 0 else False
413
414    return success, results