How do I override the default query class?

[nickretallack]

I thought this should work, but it doesn't.

[davidism]

As far as I know, you make a subclass of SQLAlchemy and override make_declarative_base. At least, that's what I do and it works fine.

[nickretallack]

It's this stackoverflow post that lead me to believe I could do it this way.

[nickretallack]

@davidism do you have an example of how to do this? It seems complicated.

[davidism]

from flask_sqlalchemy import BaseQuery, Model, _BoundDeclarativeMeta, SQLAlchemy as BaseSQLAlchemy, _QueryProperty

class MyBaseQuery(BaseQuery):
    pass  # do stuff here

class MyModel(Model):
    # in this case we're just using a custom BaseQuery class, but you can add other stuff as well
    query_class = MyBaseQuery

class SQLAlchemy(BaseSQLAlchemy):
    def make_declarative_base(self):
        # in this case we're just using a custom Model class, but you can change the DelcarativeMeta or other stuff as well
        base = declarative_base(cls=MyModel, name='Model', metaclass=_BoundDeclarativeMeta)
        base.query = _QueryProperty(self)
        return base

db = SQLAlchemy()

[davidism]

Actually, this isn't a full solution, as relationships won't get the custom class. See https://github.com/mitsuhiko/flask-sqlalchemy/blob/master/flask_sqlalchemy/__init__.py#L73 which is hard-coded to use the default BaseQuery.

[nickretallack]

It'd be cool if there was an easier way to do this. Like a single option I could set when instantiating SQLAlchemy.

[MerliX]

There is a big importance of ability to change default query class. I use flask-sqlalchemy with mysql, and used to customize count() function for sqlalchemy (by default it produces very slow SQL (link) ). I inherited BaseQuery and fixed count(), used all approaches discussed here, but i still have slow counts using db.relationship(). There is an option to set db.backref with 'query_class' param, but no option for db.relationship

[noah]

+1 basically I need to be able to write custom pagintion that does not encounter exponential complexity when using LIMIT and OFFSET. See:

http://stackoverflow.com/questions/16916633/if-postgresql-count-is-always-slow-how-to-paginate-complex-queries
http://stackoverflow.com/questions/6618366/improving-offset-performance-in-postgresql

With hard-coded Query class this is badly broken for all but the most trivial applications.

[justanr]

Hm. Simply allowing setting a query_class parameter in __init__ and passing it down to _include_sqlalchemy (and ultimately _set_default_query_class) goes most of the way towards fixing an issue like this. However, Model would still hard code the query class as BaseQuery and doing something like...

class SQLAlchemy:
    def __init__(self, query_class=BaseQuery...):
        self.Model = self.make_declarative_base(...)
        # works but you know :/
        self.Model.query_class = query_class

example of this sort of change

[immunda]

Thanks @justanr, helpful example.

This issue has now been eaten by #319 and prioritised.