can sqlalchemy clauses be evaluated without a database?

One way is head on, there is a module in SQLAlchemy used by the Query.update() and Query.delete() methods which does this called sqlalchemy.orm.evaluator. It's capable only of expressing a very limited set of expression operators:

>>> from sqlalchemy.orm.evaluator
import EvaluatorCompiler
   >>>
   print EvaluatorCompiler().process(bool_clause)(a_foo)
False
   >>>
   print EvaluatorCompiler().process(int_clause)(a_foo)
15

Now the way the use case you have is usually done is using hybrid properties and methods. In this use case, we take advantage of the awesomeness of Python in that when we have <anything>.someattr <some operator> <somethingelse>, we can swap out self and cls for <anything>. So your example would be:

class Foo(Base):
   __tablename__ = 'foo'
id = Column(Integer, primary_key = True)
bar = Column(Integer)

@hybrid_method
def bool_clause(self, other):
   return self.bar > other

@hybrid_method
def int_clause(self, other):
   return self.bar + other

      >>>
      a_foo = Foo(bar = 5) >>>
      print a_foo.bool_clause(10)
False
   >>>
   print a_foo.int_clause(10)
15

Suggestion : 2

The SQL Expression Language constructs its expressions against table columns. SQLAlchemy Column object represents a column in a database table which is in turn represented by a Tableobject. Metadata contains definitions of tables and associated objects such as index, view, triggers, etc.,Column object represents a column in a database table. Constructor takes name, type and other parameters such as primary_key, autoincrement and other constraints.,An object of Table class represents corresponding table in a database. The constructor takes the following parameters −,Complete code is given below which will create a SQLite database college.db with a students table in it.

Any version of Python higher than 2.7 is necessary to install SQLAlchemy. The easiest way to install is by using Python Package Manager, pip. This utility is bundled with standard distribution of Python.

pip install sqlalchemy

In case of anaconda distribution of Python, SQLAlchemy can be installed from conda terminal using the below command −

conda install - c anaconda sqlalchemy

It is also possible to install SQLAlchemy from below source code −

python setup.py install

The create_engine() function takes the database as one argument. The database is not needed to be defined anywhere. The standard calling form has to send the URL as the first positional argument, usually a string that indicates database dialect and connection arguments. Using the code given below, we can create a database.

>>> from sqlalchemy
import create_engine
   >>>
   engine = create_engine('sqlite:///college.db', echo = True)

For a MySQL database, use the below command −

engine = create_engine("mysql://user:pwd@localhost/college", echo = True)

Suggestion : 3

SQLAlchemy's ORM query API simplifies the way we write database queries. Instead of writing raw SQL queries, we can construct queries on our SQLAlchemy session by chaining together methods to retrieve data. We're going to dive into SQLAlchemy's extensive query API to get an idea of all the ways we can query our data.,Let's quickly become familiar with the basic structure of SQLAlchemy's query API. SQLAlchemy session objects have a query() method that accepts the raw class of a data model we've previously defined. Below are the humble beginnings of a query to run on Customer model; or in other words, a query on the customers SQL table:,Calling .query(Customer) on our session isn't a valid query until we add one more method to the chain. All session queries end with a final method to shape/anticipate the result(s) of our query:,Our SQLAlchemy journey thus far has covered managing database connections and model creation. Yet, how do we extract the data we want from our database?

""
"Database engine & session creation."
""
from sqlalchemy
import create_engine
from sqlalchemy.orm
import sessionmaker

engine = create_engine(
   'mysql+pymysql://user:password@host:3600/database',
   echo = True
)
Session = sessionmaker(bind = engine)
session = Session()

""
"Construct database queries from SQLAlchemy sessions."
""
from.database
import session
from.models
import Customer

# Example structure of an ORM query
records = session
   .query(Customer)
   .FUNCTION()

""
"Construct database queries from SQLAlchemy sessions."
""
from.database
import session
from.models
import Customer

# Example structure of an ORM query
records = session
   .query(Customer)
   .METHOD_1()
   .METHOD_2()
   .FUNCTION()

""
"Construct database queries from SQLAlchemy sessions."
""
from.database
import session
from.models
import Customer

# Fetch all customer records
records = session
   .query(Customer)
   .all()

# Loop over records
for record in records:
   print(record)

<Customer model 1>
   <Customer model 2>
      <Customer model 3>
         <Customer model 4>
            <Customer model 5>
               <Customer model 6>
                  <Customer model 7>
                     <Customer model 8>
                        <Customer model 9>
                           <Customer model 10>

...

records = session
   .query(Customer)
   .all()

for record in records:
   pp.pprint(record.__dict__)