order_id = bindparam('order_id', required=True)
return \
    select(
        func.count(Product.id).label("product_count"),
        func.sum(Product.price).label("order_price"),
        Customer.name,
    )\
    .select_from(Order)\
    .join(
        Product,
        onclause=(Product.id == Order.product_id),
    )\
    .join(
        Customer,
        onclause=(Customer.id == Order.customer_id),
    )\
    .where(
        Order.id == order_id,
    )\
    .group_by(
        Order.id,
    )\
    .order_by(
        Product.id.desc(),
    )

from functools import lru_cache
def cached_classmethod(target):
    cache = lru_cache(maxsize=None)
    cached = cache(target)
    cached = classmethod(cached)
    return cached

class BaseViewMixin:
    def build_query_plan(self):
        self.query_kwargs = {}
        self.query_params = frozenset()
    async def main(self):
        self.build_query_plan()
        query = self.query(self.query_params)
        async with BaseModel.session() as session:
            respone = await session.execute(
                query,
                self.query_kwargs,
            )
            mappings = respone.mappings()
        return self.serialize(mappings)

stmt = lambdas.lambda_stmt(lambda: future_select(Customer))
stmt += lambda s: s.where(Customer.id == id_)

class FutureSelectWrapper:
    def __init__(self, clause):
        self.stmt = lambdas.lambda_stmt(
            lambda: future_select(clause)
        )
    def __getattribute__(self, name):
        def outer(clause):
            def inner(s):
                callback = getattr(s, name)
                return callback(clause)
            self.stmt += inner
            return self
        return outer

class ColorType(TypeDecorator):
    impl = Integer
    cache_ok = True
    def process_result_value(self, value, dialect):
        if value is None:
            return
        return color(value)
    def process_bind_param(self, value, dialect):
        if value is None:
            return
        value = color(value)
        return value.value

class IntEnumField(TypeEngine):
    def __init__(self, target_enum):
        self.target_enum = target_enum
        self.value2member_map = target_enum._value2member_map_
        self.member_map = target_enum._member_map_
    def get_dbapi_type(self, dbapi):
        return dbapi.NUMBER
    def result_processor(self, dialect, coltype):
        def process(value):
            if value is None:
                return
            member = self.value2member_map[value]
            return member.name
        return process
    def bind_processor(self, dialect):
        def process(value):
            if value is None:
                return
            member = self.member_map[value]
            return member.value
        return process

from sqlalchemy.sql.functions import GenericFunction, register_function
from sqlalchemy.sql import sqltypes
from sqlalchemy import func, literal_column
def register(target):
    name = target.__name__
    register_function(name, target)
    return target
# === Database functions ===
class json_quote(GenericFunction):
    type = sqltypes.String
    inherit_cache = True
class json_object(GenericFunction):
    type = sqltypes.JSON
    inherit_cache = True
# === Macro ===
empty_string = literal_column("''", type_=sqltypes.String)
json_array_open = literal_column("'['", type_=sqltypes.String)
json_array_close = literal_column("']'", type_=sqltypes.String)
@register
def json_arrayagg_workaround(clause):
    clause_type = clause.type
    if isinstance(clause_type, sqltypes.String):
        clause = func.json_quote(clause)
    clause = func.group_concat(clause)
    clause = func.coalesce(clause, empty_string)
    return func.concat(
        json_array_open,
        clause,
        json_array_close,
        type_=sqltypes.JSON,
    )
def __json_pairs_iter(clauses):
    for clause in clauses:
        clause_name = clause.name
        clause_name = "'%s'" % clause_name
        yield literal_column(clause_name, type_=sqltypes.String)
        yield clause
@register
def json_object_wrapper(*clauses):
    json_pairs = __json_pairs_iter(clauses)
    return func.json_object(*json_pairs)

SELECT concat(
  '[',
  coalesce(group_concat(product.tag_id), ''),
  ']'
) AS product_tags

SELECT json_object(
  'name', product.name,
  'price', product.price
) AS product,