internal.queries.inbox 

  1# Code generated by sqlc. DO NOT EDIT.
  2# versions:
  3#   sqlc v1.30.0
  4# source: inbox.sql
  5import pydantic
  6from typing import AsyncIterator, Optional
  7
  8import sqlalchemy
  9import sqlalchemy.ext.asyncio
 10
 11from internal.queries import models
 12
 13
 14CREATE_INBOX_MESSAGE = """-- name: create_inbox_message \\:one
 15INSERT INTO inbox (user_id, sender_id, message_subject, message_text)
 16VALUES (:p1, :p2, :p3, :p4)
 17RETURNING message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status
 18"""
 19
 20
 21class CreateInboxMessageParams(pydantic.BaseModel):
 22    user_id: int
 23    sender_id: int
 24    message_subject: str
 25    message_text: str
 26
 27
 28DELETE_INBOX_MESSAGE = """-- name: delete_inbox_message \\:one
 29DELETE FROM inbox
 30WHERE message_id = :p1
 31RETURNING message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status
 32"""
 33
 34
 35GET_INBOXES = """-- name: get_inboxes \\:many
 36SELECT message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status
 37FROM inbox
 38"""
 39
 40
 41GET_USER_INBOX = """-- name: get_user_inbox \\:many
 42SELECT message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status
 43FROM inbox
 44WHERE user_id = :p1
 45"""
 46
 47
 48class AsyncQuerier:
 49    def __init__(self, conn: sqlalchemy.ext.asyncio.AsyncConnection):
 50        self._conn = conn
 51
 52    async def create_inbox_message(self, arg: CreateInboxMessageParams) -> Optional[models.Inbox]:
 53        row = (await self._conn.execute(sqlalchemy.text(CREATE_INBOX_MESSAGE), {
 54            "p1": arg.user_id,
 55            "p2": arg.sender_id,
 56            "p3": arg.message_subject,
 57            "p4": arg.message_text,
 58        })).first()
 59        if row is None:
 60            return None
 61        return models.Inbox(
 62            message_id=row[0],
 63            user_id=row[1],
 64            sender_id=row[2],
 65            message_subject=row[3],
 66            message_text=row[4],
 67            sent_at=row[5],
 68            read_status=row[6],
 69        )
 70
 71    async def delete_inbox_message(self, *, message_id: int) -> Optional[models.Inbox]:
 72        row = (await self._conn.execute(sqlalchemy.text(DELETE_INBOX_MESSAGE), {"p1": message_id})).first()
 73        if row is None:
 74            return None
 75        return models.Inbox(
 76            message_id=row[0],
 77            user_id=row[1],
 78            sender_id=row[2],
 79            message_subject=row[3],
 80            message_text=row[4],
 81            sent_at=row[5],
 82            read_status=row[6],
 83        )
 84
 85    async def get_inboxes(self) -> AsyncIterator[models.Inbox]:
 86        result = await self._conn.stream(sqlalchemy.text(GET_INBOXES))
 87        async for row in result:
 88            yield models.Inbox(
 89                message_id=row[0],
 90                user_id=row[1],
 91                sender_id=row[2],
 92                message_subject=row[3],
 93                message_text=row[4],
 94                sent_at=row[5],
 95                read_status=row[6],
 96            )
 97
 98    async def get_user_inbox(self, *, user_id: int) -> AsyncIterator[models.Inbox]:
 99        result = await self._conn.stream(sqlalchemy.text(GET_USER_INBOX), {"p1": user_id})
100        async for row in result:
101            yield models.Inbox(
102                message_id=row[0],
103                user_id=row[1],
104                sender_id=row[2],
105                message_subject=row[3],
106                message_text=row[4],
107                sent_at=row[5],
108                read_status=row[6],
109            )
CREATE_INBOX_MESSAGE = '-- name: create_inbox_message \\:one\nINSERT INTO inbox (user_id, sender_id, message_subject, message_text)\nVALUES (:p1, :p2, :p3, :p4)\nRETURNING message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status\n'
class CreateInboxMessageParams(pydantic.main.BaseModel): 
22class CreateInboxMessageParams(pydantic.BaseModel):
23    user_id: int
24    sender_id: int
25    message_subject: str
26    message_text: str

!!! abstract "Usage Documentation" Models

A base class for creating Pydantic models.

Attributes:
  • __class_vars__: The names of the class variables defined on the model.
  • __private_attributes__: Metadata about the private attributes of the model.
  • __signature__: The synthesized __init__ [Signature][inspect.Signature] of the model.
  • __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
  • __pydantic_core_schema__: The core schema of the model.
  • __pydantic_custom_init__: Whether the model has a custom __init__ function.
  • __pydantic_decorators__: Metadata containing the decorators defined on the model. This replaces Model.__validators__ and Model.__root_validators__ from Pydantic V1.
  • __pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
  • __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
  • __pydantic_post_init__: The name of the post-init method for the model, if defined.
  • __pydantic_root_model__: Whether the model is a [RootModel][pydantic.root_model.RootModel].
  • __pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
  • __pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
  • __pydantic_fields__: A dictionary of field names and their corresponding [FieldInfo][pydantic.fields.FieldInfo] objects.
  • __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [ComputedFieldInfo][pydantic.fields.ComputedFieldInfo] objects.
  • __pydantic_extra__: A dictionary containing extra values, if [extra][pydantic.config.ConfigDict.extra] is set to 'allow'.
  • __pydantic_fields_set__: The names of fields explicitly set during instantiation.
  • __pydantic_private__: Values of private attributes set on the model instance.
user_id: int = PydanticUndefined
sender_id: int = PydanticUndefined
message_subject: str = PydanticUndefined
message_text: str = PydanticUndefined
DELETE_INBOX_MESSAGE = '-- name: delete_inbox_message \\:one\nDELETE FROM inbox\nWHERE message_id = :p1\nRETURNING message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status\n'
GET_INBOXES = '-- name: get_inboxes \\:many\nSELECT message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status\nFROM inbox\n'
GET_USER_INBOX = '-- name: get_user_inbox \\:many\nSELECT message_id, user_id, sender_id, message_subject, message_text, sent_at, read_status\nFROM inbox\nWHERE user_id = :p1\n'
class AsyncQuerier: 
 49class AsyncQuerier:
 50    def __init__(self, conn: sqlalchemy.ext.asyncio.AsyncConnection):
 51        self._conn = conn
 52
 53    async def create_inbox_message(self, arg: CreateInboxMessageParams) -> Optional[models.Inbox]:
 54        row = (await self._conn.execute(sqlalchemy.text(CREATE_INBOX_MESSAGE), {
 55            "p1": arg.user_id,
 56            "p2": arg.sender_id,
 57            "p3": arg.message_subject,
 58            "p4": arg.message_text,
 59        })).first()
 60        if row is None:
 61            return None
 62        return models.Inbox(
 63            message_id=row[0],
 64            user_id=row[1],
 65            sender_id=row[2],
 66            message_subject=row[3],
 67            message_text=row[4],
 68            sent_at=row[5],
 69            read_status=row[6],
 70        )
 71
 72    async def delete_inbox_message(self, *, message_id: int) -> Optional[models.Inbox]:
 73        row = (await self._conn.execute(sqlalchemy.text(DELETE_INBOX_MESSAGE), {"p1": message_id})).first()
 74        if row is None:
 75            return None
 76        return models.Inbox(
 77            message_id=row[0],
 78            user_id=row[1],
 79            sender_id=row[2],
 80            message_subject=row[3],
 81            message_text=row[4],
 82            sent_at=row[5],
 83            read_status=row[6],
 84        )
 85
 86    async def get_inboxes(self) -> AsyncIterator[models.Inbox]:
 87        result = await self._conn.stream(sqlalchemy.text(GET_INBOXES))
 88        async for row in result:
 89            yield models.Inbox(
 90                message_id=row[0],
 91                user_id=row[1],
 92                sender_id=row[2],
 93                message_subject=row[3],
 94                message_text=row[4],
 95                sent_at=row[5],
 96                read_status=row[6],
 97            )
 98
 99    async def get_user_inbox(self, *, user_id: int) -> AsyncIterator[models.Inbox]:
100        result = await self._conn.stream(sqlalchemy.text(GET_USER_INBOX), {"p1": user_id})
101        async for row in result:
102            yield models.Inbox(
103                message_id=row[0],
104                user_id=row[1],
105                sender_id=row[2],
106                message_subject=row[3],
107                message_text=row[4],
108                sent_at=row[5],
109                read_status=row[6],
110            )
AsyncQuerier(conn: sqlalchemy.ext.asyncio.engine.AsyncConnection) 
50    def __init__(self, conn: sqlalchemy.ext.asyncio.AsyncConnection):
51        self._conn = conn
async def create_inbox_message( self, arg: CreateInboxMessageParams) -> internal.queries.models.Inbox | None: 
53    async def create_inbox_message(self, arg: CreateInboxMessageParams) -> Optional[models.Inbox]:
54        row = (await self._conn.execute(sqlalchemy.text(CREATE_INBOX_MESSAGE), {
55            "p1": arg.user_id,
56            "p2": arg.sender_id,
57            "p3": arg.message_subject,
58            "p4": arg.message_text,
59        })).first()
60        if row is None:
61            return None
62        return models.Inbox(
63            message_id=row[0],
64            user_id=row[1],
65            sender_id=row[2],
66            message_subject=row[3],
67            message_text=row[4],
68            sent_at=row[5],
69            read_status=row[6],
70        )
async def delete_inbox_message(self, *, message_id: int) -> internal.queries.models.Inbox | None: 
72    async def delete_inbox_message(self, *, message_id: int) -> Optional[models.Inbox]:
73        row = (await self._conn.execute(sqlalchemy.text(DELETE_INBOX_MESSAGE), {"p1": message_id})).first()
74        if row is None:
75            return None
76        return models.Inbox(
77            message_id=row[0],
78            user_id=row[1],
79            sender_id=row[2],
80            message_subject=row[3],
81            message_text=row[4],
82            sent_at=row[5],
83            read_status=row[6],
84        )
async def get_inboxes(self) -> AsyncIterator[internal.queries.models.Inbox]: 
86    async def get_inboxes(self) -> AsyncIterator[models.Inbox]:
87        result = await self._conn.stream(sqlalchemy.text(GET_INBOXES))
88        async for row in result:
89            yield models.Inbox(
90                message_id=row[0],
91                user_id=row[1],
92                sender_id=row[2],
93                message_subject=row[3],
94                message_text=row[4],
95                sent_at=row[5],
96                read_status=row[6],
97            )
async def get_user_inbox(self, *, user_id: int) -> AsyncIterator[internal.queries.models.Inbox]: 
 99    async def get_user_inbox(self, *, user_id: int) -> AsyncIterator[models.Inbox]:
100        result = await self._conn.stream(sqlalchemy.text(GET_USER_INBOX), {"p1": user_id})
101        async for row in result:
102            yield models.Inbox(
103                message_id=row[0],
104                user_id=row[1],
105                sender_id=row[2],
106                message_subject=row[3],
107                message_text=row[4],
108                sent_at=row[5],
109                read_status=row[6],
110            )