1

"""

     2

    Application runtime state

     3

"""

     4

     5

from sqlalchemy import create_engine

     6

     7

import logging

     8

     9

from svv import database as db

    10

    11

log = logging.getLogger('svv.app')

    12

    13

class Application (object) :

    14

    """

    15

        Our core run-time state, which e.g. WSGIAoo acts as a frontend to

    16

    """

    17

    18

    def __init__ (self, db_url) :

    19

        """

    20

            Initialize app, connecting to database.

    21

    22

                db_url      - sqlalchemy-style URL to database

    23

        """

    24

    25

        if db_url :

    26

            # connect

    27

            self._engine = engine = create_engine(db_url)

    28

    29

            log.info("Connected to database %s", engine)

    30

    31

        else :

    32

            self._engine = None

    33

    34

    @property

    35

    def engine (self) :

    36

        """

    37

            Our sqlalchemy engine providing access to our database

    38

        """

    39

    40

        if not self._engine :

    41

            raise RuntimeError("No database configured")

    42

    43

        return self._engine

    44

    45

    def create_tables (self) :

    46

        """

    47

            Initialize the database if new.

    48

        """

    49

    50

        log.warn("Creating database tables...")

    51

    52

        db.schema.create_all(self.engine)

    53

    54

    def get_connection (self) :

    55

        """

    56

            Return an active sqlalchemy Connection for our database.

    57

        """

    58

    59

        return self.engine.connect()

    60

    61

    def query (self, sql) :

    62

        """

    63

            Execute a simple SQL query, and return results

    64

        """

    65

    66

        return self.engine.execute(sql)

    67

    68

    def insert (self, sql, **values) :

    69

        """

    70

            Execute a simple SQL insert, returning the new IDs a a tuple.

    71

    72

            For the common case of a table with a simplex primary key, a call looks like:

    73

    74

                new_id, = app.insert(sql, foo=bar)

    75

        """

    76

    77

        return self.engine.execute(sql, **values).last_inserted_ids()

    78

    79

    def execute (self, sql, **values) :

    80

        """

    81

            Execute an SQL statement (UPDATE) that doesn't return any values.

    82

        """

    83

    84

        self.engine.execute(sql, **values)

    85

    86

    # XXX: rename this to something else, conflicts, to some degree, with web session with cookies (although using

    87

    # SQL transctions at that level would be pretty cool..)

    88

    # orm orm_session objects dbsession dbmapping dbmaps 

    89

    def session (self) :

    90

        """

    91

            Return a new SQLAlchemy database session, for use with ORM mapped objects.

    92

        """

    93

    94

        return db.session_factory(bind=self.engine)

    95