Example #1
0
 def items(self):
     '''Returns items on the current page.'''
     if isinstance(self.collection, Query):
         query = self.collection
         if sqav.startswith("0.4"):
             attribute = getattr(query.table.c,
                                 self.alpha_attribute)
         elif sqav.startswith("0.5"):
              attribute = getattr(query._entity_zero().selectable.c,	
                                  self.alpha_attribute)
         else:
             entity = getattr(query.column_descriptions[0]['expr'],
                              self.alpha_attribute)
             query = query.add_columns(entity)
             column = dropwhile(lambda x: x['name'] != \
                                self.alpha_attribute,
                                query.column_descriptions)
             attribute = column.next()['expr']
         if self.item_count >= self.paging_threshold:
             if self.page != self.other_text:
                 query = query.filter(attribute.ilike(u'%s%%' % self.page))
             else:
                 # regexp search
                 query = query.filter(attribute.op('~')(u'^[^a-zA-Z].*'))
         query.order_by(attribute)
         return query.all()                                   
     else:
         raise NotImplementedError
Example #2
0
    def test_column_create(self):
        if sqav.startswith("0.6") or sqav.startswith("0.7"):
            ## FIXME???
            ## This test does not appear to test anything that is
            ## VDM specific. It also fails with SQLAlchemy 0.6
            ## Does this test really belong here?
            return
        
        tabxyz = Table('xyz', metadata,
            Column('id', Integer, primary_key=True)
            )
        col = Column('abc', Integer, ForeignKey('xyz.id'))
        # FK does *not* work
        assert len(col.foreign_keys) == 0
        tab = Table('tab', metadata,
            Column('abc', Integer, ForeignKey('xyz.id')),
            )
        col0 = tab.c['abc']
        fk0 = col0.foreign_keys[0]
        assert len(col0.foreign_keys) == 1
        assert fk0.parent is not None

        tab2 = Table('tab', metadata)
        tab2.append_column(
            Column('abc', Integer, ForeignKey('xyz.id'))
            )
        assert len(tab2.c['abc'].foreign_keys) == 1
        assert tab2.c['abc'].foreign_keys[0].parent is not None

        tab3 = Table('tab', metadata)
        col3 = col0.copy()
        col3.foreign_keys.add(tab.c['abc'].foreign_keys[0].copy())
        tab3.append_column(col3)
        assert len(tab3.c['abc'].foreign_keys) == 1
        # fails
        # assert tab3.c['abc'].foreign_keys[0].parent

        tab3 = Table('tab', metadata)
        col3 = col0.copy()
        tab3.append_column(col3)
        col3.foreign_keys.add(ForeignKey(col0.key)) 
        assert len(tab3.c['abc'].foreign_keys) == 1
        # fails
        # assert tab3.c['abc'].foreign_keys[0].parent
        tab4 = Table('tab', metadata)
        tab4.append_column(
            col0.copy()
            )
        tab4.c[col0.key].append_foreign_key(fk0.copy())
        assert len(tab4.c['abc'].foreign_keys) == 1
        assert tab4.c['abc'].foreign_keys[0].parent is not None
 def items(self):
     '''Returns items on the current page.'''
     if isinstance(self.collection, Query):
         query = self.collection
         if sqav.startswith("0.4"):
             attribute = getattr(query.table.c,
                                 self.alpha_attribute)
         elif sqav.startswith("0.5"):
              attribute = getattr(query._entity_zero().selectable.c,
                                  self.alpha_attribute)
         else:
             entity = getattr(query.column_descriptions[0]['expr'],
                              self.alpha_attribute)
             query = query.add_columns(entity)
             column = dropwhile(lambda x: x['name'] != \
                                self.alpha_attribute,
                                query.column_descriptions)
             attribute = column.next()['expr']
         if self.item_count >= self.paging_threshold:
             if self.page != self.other_text:
                 query = query.filter(attribute.ilike(u'%s%%' % self.page))
             else:
                 # regexp search
                 query = query.filter(attribute.op('~')(u'^[^a-zA-Z].*'))
         query.order_by(attribute)
         return query.all()
     elif isinstance(self.collection,list):
         if self.item_count >= self.paging_threshold:
             if self.page != self.other_text:
                 print '\ndict es '+str(dict)
                 if isinstance(self.collection[0], dict):
                     items = [x for x in self.collection if x[self.alpha_attribute][0:1].lower() == self.page.lower()]
                 elif isinstance(self.collection[0], unicode):
                     items = [x for x in self.collection if x[0:1].lower() == self.page.lower()]
                 else:
                     items = [x for x in self.collection if getattr(x,self.alpha_attribute)[0:1].lower() == self.page.lower()]
             else:
                 # regexp search
                 if isinstance(self.collection[0], dict):
                     items = [x for x in self.collection if re.match('^[^a-zA-Z].*',x[self.alpha_attribute])]
                 else:
                     items = [x for x in self.collection if re.match('^[^a-zA-Z].*',x)]
             items.sort()
         else:
             items = self.collection
         return items
     else:
         raise NotImplementedError
    def test_03_reorder_resources(self):
        rev = model.repo.new_revision()
        pkg = model.Package.by_name(self.pkgname)
        rg = pkg.resource_groups[0]

        res0 = rg.resources[0]
        del rg.resources[0]
        rg.resources.append(res0)
        # this assert will fail
        # assert pkg.resources[1].position == 1
        # Why? According to docs for ordering list it does not reorder appended
        # elements by default (see
        # http://www.sqlalchemy.org/trac/browser/lib/sqlalchemy/ext/orderinglist.py#L197)
        # so we have to call reorder directly in supported versions
        # of sqlalchemy and set position to None in older ones.
        if sqav.startswith('0.4'):
            rg.resources[1].position = None
        else:
            rg.resources.target.reorder()
        model.repo.commit_and_remove()

        pkg = model.Package.by_name(self.pkgname)
        assert len(rg.resources) == 3, rg.resources
        lastres = rg.resources[2]
        assert lastres.position == 2, lastres
        assert lastres.url == self.urls[0], lastres.url
Example #5
0
 def _has_property(cls, name):
     """Check if the related mapper has the given property"""
     mapper = cls.__mapper__
     if sa_version.startswith('0.4'):
         return mapper.get_property(name, raiseerr=False) is not None
     else:
         return mapper.has_property(name)
Example #6
0
 def delete_all(self):
     '''Delete all data from all tables.'''
     self.session.remove()
     ## use raw connection for performance
     connection = self.session.connection()
     if sqav.startswith("0.4"):
         tables = self.metadata.table_iterator()
     else:
         tables = reversed(self.metadata.sorted_tables)
     for table in tables:
         connection.execute('delete from "%s"' % table.name)
     self.session.commit()
Example #7
0
File: base.py Project: Spencerx/vdm
 def check_real_change(self, instance, mapper, connection):
     # check each attribute to see if they have been changed
     logger.debug('check_real_change: %s', instance)
     if sqav.startswith("0.4"):
         state = instance._state
     else:
         state = instance
     for key in instance.revisioned_fields():
         (added, unchanged, deleted) = get_history(state,
                                                   key,
                                                   passive=PASSIVE_OFF)
         if added or deleted:
             logger.debug('check_real_change: True')
             return True
     logger.debug('check_real_change: False')
     return False
Example #8
0
File: base.py Project: okfn/vdm
 def check_real_change(self, instance, mapper, connection):
     # check each attribute to see if they have been changed
     logger.debug('check_real_change: %s', instance)
     if sqav.startswith("0.4"):
         state = instance._state
     else:
         state = instance
     for key in instance.revisioned_fields():
         (added, unchanged, deleted) = get_history(state,
                                                   key,
                                                   passive = PASSIVE_OFF)
         if added or deleted:
             logger.debug('check_real_change: True')
             return True
     logger.debug('check_real_change: False')
     return False
Example #9
0
def smc_sa10_workaround(prop):
    def add_event_handlers():
        # We have the relationship from the child to the parent but we
        # need the inverse. This is only defined after the mapper has
        # been configured. That's why this is inside a listener for the
        # "after_configured" event.
        parent_prop = getattr(prop.mapper.class_, prop.back_populates)

        def cb_on_init(target, coll, adapter):
            coll.on_init()
        event.listen(parent_prop, "init_collection", cb_on_init)

        def cb_on_dispose(target, coll, adapter):
            coll.on_dispose()
        event.listen(parent_prop, "dispose_collection", cb_on_dispose)

    if sa_version.startswith("1."):
        event.listen(mapper, "after_configured", add_event_handlers)

    return prop
Example #10
0
def smc_sa10_workaround(prop):
    def add_event_handlers():
        # We have the relationship from the child to the parent but we
        # need the inverse. This is only defined after the mapper has
        # been configured. That's why this is inside a listener for the
        # "after_configured" event.
        parent_prop = getattr(prop.mapper.class_, prop.back_populates)

        def cb_on_init(target, coll, adapter):
            coll.on_init()

        event.listen(parent_prop, "init_collection", cb_on_init)

        def cb_on_dispose(target, coll, adapter):
            coll.on_dispose()

        event.listen(parent_prop, "dispose_collection", cb_on_dispose)

    if sa_version.startswith("1."):
        event.listen(mapper, "after_configured", add_event_handlers)

    return prop
Example #11
0
def initialize_defered_mappers(metadata):
    # Execute __declare__last__ for sqlalchemy 0.4
    ignored_tables = []
    for mapper in declaratives_mappers(metadata):
        # http://docs.sqlalchemy.org/en/rel_0_7/orm/extensions/declarative.html#declare-last
        if verify_mapper(mapper, metadata) is False:
            continue
        if mapper._create_table is False:
            tname = '.'.join([e for e in [mapper.__table__.schema,
                                          mapper.__table__.name] if e])
            ignored_tables.append(tname)
        if sa_version.startswith('0.4') and hasattr(mapper, '__declare_last__') is True:
            mapper.__declare_last__()
        if hasattr(mapper, '_create_relations'):
            mapper._create_relations()
    # Fix defaults for tests
    if metadata.bind.name == 'sqlite':
        if sqlalchemy.__version__.startswith('0.4'):
            set_sqlite_defaults(metadata)
    # Avoid an error with the immutabledict from SA 0.8
    tables = dict(metadata.tables)
    for tname in ignored_tables:
        del tables[tname]
    metadata.tables = tables
Example #12
0
    print "SqlAlchemy was not found, please install it !"
    sys.exit(1)


def usage(argv):
    print >> sys.stderr, 'Usage: %s db_conn_string [--id entity_id|--name entity_name]' % argv[
        0]
    print >> sys.stderr, 'Where db_conn_string is a SQLAlchemy connection string, e.g. mysql://user:password@host/database'
    return 1


if __name__ == "__main__":
    if len(sys.argv) != 2 and len(sys.argv) != 4:
        sys.exit(usage(sys.argv))

    if not __version__.startswith('0.4'):
        print "Wrong version of SqlAlchemy found, please install a 0.4 version !"
        sys.exit(1)

    get_entity = False
    if len(sys.argv) == 4:
        if sys.argv[2] == '--id':
            id_entity = sys.argv[3]
            get_entity = True
        elif sys.argv[2] == '--name':
            id_entity = -1
            name_entity = sys.argv[3]
            get_entity = True
        else:
            print "dont know this option : %s" % sys.argv[2]
            sys.exit(1)
Example #13
0
# -*- encoding: utf-8 -*-

import os
parentpath = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
from web.utils import Storage
from sqlalchemy import __version__ as sqlalchemy_version

sitepath = None
if sqlalchemy_version.startswith("0.5"):
    db = "postgres:///soc"
else:
    db = "postgresql:///soc"
init = "socmembers.xml"
instance = u"soc"
secret = u"..."
cookie = "soclogin"
maps_key = Storage(http="ABQIAAAAnfs7bKE82qgb3Zc2YyS-oBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxSySz_REpPq-4WZA27OwgbtyR3VcA")
pdflatex = "/usr/bin/pdflatex"
xsltproc = "/usr/bin/xsltproc"
tmppath = "/tmp/socmanager"
photopath = os.path.join(parentpath, "photos")
thumbpath = os.path.join(parentpath, "var", "spool", "socmanager", "thumb")
midpath = os.path.join(parentpath, "var", "spool", "socmanager", "mid")
formats = [Storage(processor="tex", name="full", description=u"Komplettliste mit allen Informationen (pdf)", cls="full.cls", merge=None, hide_private=False),
           Storage(processor="tex", name="project", description=u"Projektliste zum Verteilen (pdf)", cls="project.cls", merge=None, hide_private=True),
           Storage(processor="tex", name="chorverband", description=u"Mitgliederliste für Chorverband (pdf)", cls="chorverband.cls", merge=None, hide_private=False),
           Storage(processor="tex", name="address_sticker", description=u"Addressettikten (pdf)", cls="address_sticker.cls", merge="address", hide_private=True),
           Storage(processor="tex", name="address_panel", description=u"Addressaufdruck für Fensterumschläge (pdf)", cls="address_panel.cls", merge="address", hide_private=True),
           Storage(processor="tex", name="badge", description=u"Namensschilder (pdf)", cls="badge.cls", merge=None, hide_private=True),
           Storage(processor="tex", name="voucher", description=u"Gutschein (pdf)", cls="voucher.cls", merge=None, hide_private=True),
           Storage(processor="xml", name="kml", description=u"Google Earth Datei (kml)", xslt="kml.xslt", merge="address", mime="application/vnd.google-earth.kml+xml", extension="kml", hide_private=True),
Example #14
0
# http://blog.pythonisito.com/2008/01/cascading-drop-table-with-sqlalchemy.html
from sqlalchemy import __version__ as sqav
if sqav[:3] in ("0.4", "0.5"):
    from sqlalchemy.databases import postgres

    class CascadeSchemaDropper(postgres.PGSchemaDropper):
        def visit_table(self, table):
            for column in table.columns:
                if column.default is not None:
                    self.traverse_single(column.default)
            self.append("\nDROP TABLE " + self.preparer.format_table(table) +
                        " CASCADE")
            self.execute()

    postgres.dialect.schemadropper = CascadeSchemaDropper
elif sqav.startswith("0.6") or sqav.startswith("0.7") or sqav.startswith(
        "0.8"):
    from sqlalchemy.dialects.postgresql import base

    def visit_drop_table(self, drop):
        return "\nDROP TABLE " + \
               self.preparer.format_table(drop.element) + \
               " CASCADE"

    base.dialect.ddl_compiler.visit_drop_table = visit_drop_table
else:
    raise ValueError(
        "VDM only works with SQLAlchemy versions 0.4 through 0.8, not: %s" %
        sqav)

from sqlalchemy import create_engine
Example #15
0
class SaMappedClassAlias(pyamf.ClassAlias):
    KEY_ATTR = 'sa_key'
    LAZY_ATTR = 'sa_lazy'
    EXCLUDED_ATTRS = [
        '_entity_name', '_instance_key', '_sa_adapter', '_sa_appender',
        '_sa_class_manager', '_sa_initiator', '_sa_instance_state',
        '_sa_instrumented', '_sa_iterator', '_sa_remover', '_sa_session_id',
        '_state'
    ]

    STATE_ATTR = '_sa_instance_state'

    if __version__.startswith('0.4'):
        STATE_ATTR = '_state'

    def getCustomProperties(self):
        self.mapper = class_mapper(self.klass)
        self.exclude_attrs.update(self.EXCLUDED_ATTRS)

        self.properties = []

        for prop in self.mapper.iterate_properties:
            self.properties.append(prop.key)

        self.encodable_properties.update(self.properties)
        self.decodable_properties.update(self.properties)

        self.exclude_sa_key = self.KEY_ATTR in self.exclude_attrs
        self.exclude_sa_lazy = self.LAZY_ATTR in self.exclude_attrs

    def getEncodableAttributes(self, obj, **kwargs):
        """
        Returns a C{tuple} containing a dict of static and dynamic attributes
        for C{obj}.
        """
        attrs = pyamf.ClassAlias.getEncodableAttributes(self, obj, **kwargs)

        if not self.exclude_sa_key:
            # primary_key_from_instance actually changes obj.__dict__ if
            # primary key properties do not already exist in obj.__dict__
            attrs[self.KEY_ATTR] = self.mapper.primary_key_from_instance(obj)

        if not self.exclude_sa_lazy:
            lazy_attrs = []

            for attr in self.properties:
                if attr not in obj.__dict__:
                    lazy_attrs.append(attr)

            attrs[self.LAZY_ATTR] = lazy_attrs

        return attrs

    def getDecodableAttributes(self, obj, attrs, **kwargs):
        """
        """
        attrs = pyamf.ClassAlias.getDecodableAttributes(
            self, obj, attrs, **kwargs)

        # Delete lazy-loaded attrs.
        #
        # Doing it this way ensures that lazy-loaded attributes are not
        # attached to the object, even if there is a default value specified
        # in the __init__ method.
        #
        # This is the correct behavior, because SQLAlchemy ignores __init__.
        # So, an object retreived from a DB with SQLAlchemy will not have a
        # lazy-loaded value, even if __init__ specifies a default value.
        if self.LAZY_ATTR in attrs:
            obj_state = None

            if hasattr(orm.attributes, 'instance_state'):
                obj_state = orm.attributes.instance_state(obj)

            for lazy_attr in attrs[self.LAZY_ATTR]:
                if lazy_attr in obj.__dict__:
                    # Delete directly from the dict, so
                    # SA callbacks are not triggered.
                    del obj.__dict__[lazy_attr]

                # Delete from committed_state so SA thinks this attribute was
                # never modified.
                #
                # If the attribute was set in the __init__ method,
                # SA will think it is modified and will try to update
                # it in the database.
                if obj_state is not None:
                    if lazy_attr in obj_state.committed_state:
                        del obj_state.committed_state[lazy_attr]
                    if lazy_attr in obj_state.dict:
                        del obj_state.dict[lazy_attr]

                if lazy_attr in attrs:
                    del attrs[lazy_attr]

            del attrs[self.LAZY_ATTR]

        if self.KEY_ATTR in attrs:
            del attrs[self.KEY_ATTR]

        return attrs

    def createInstance(self, *args, **kwargs):
        self.compile()

        return self.mapper.class_manager.new_instance()
Example #16
0
# -*- encoding: utf-8 -*-

import os
parentpath = os.path.normpath(
    os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
from web.utils import Storage
from sqlalchemy import __version__ as sqlalchemy_version

sitepath = None
if sqlalchemy_version.startswith("0.5"):
    db = "postgres:///soc"
else:
    db = "postgresql:///soc"
init = "socmembers.xml"
instance = u"soc"
secret = u"..."
cookie = "soclogin"
pdflatex = "/usr/bin/pdflatex"
xsltproc = "/usr/bin/xsltproc"
tmppath = "/tmp/socmanager"
photopath = os.path.join(parentpath, "photos")
thumbpath = os.path.join(parentpath, "var", "spool", "socmanager", "thumb")
midpath = os.path.join(parentpath, "var", "spool", "socmanager", "mid")
formats = [
    Storage(processor="tex",
            name="full",
            description=u"Komplettliste mit allen Informationen (pdf)",
            cls="full.cls",
            merge=None,
            hide_private=False),
    Storage(processor="tex",
Example #17
0
# Copyright 2011 Lincoln de Sousa <*****@*****.**>.
# Copyright 2012, 2013, 2014, 2015, 2016 Jeffrey Finkelstein
#           <*****@*****.**> and contributors.
#
# This file is part of Flask-Restless.
#
# Flask-Restless is distributed under both the GNU Affero General Public
# License version 3 and under the 3-clause BSD license. For more
# information, see LICENSE.AGPL and LICENSE.BSD.
"""Helper functions for view classes."""
from sqlalchemy.exc import OperationalError
from sqlalchemy.inspection import inspect as sqlalchemy_inspect
from sqlalchemy.sql import func
from sqlalchemy import __version__ as SQLALCHEMY_VERSION

SQLALCHEMY_14 = SQLALCHEMY_VERSION.startswith('1.4.')


def upper_keys(dictionary):
    """Returns a new dictionary with the keys of ``dictionary``
    converted to upper case and the values left unchanged.

    """
    return {k.upper(): v for k, v in dictionary.items()}


def evaluate_functions(session, model, functions):
    """Executes each of the SQLAlchemy functions specified in ``functions``, a
    list of dictionaries of the form described below, on the given model and
    returns a dictionary mapping function name (slightly modified, see below)
    to result of evaluation of that function.
Example #18
0
                )

    def after_commit(self, session):
        if hasattr(session, '_object_cache'):
            del session._object_cache

    def after_rollback(self, session):
        if hasattr(session, '_object_cache'):
            del session._object_cache

# __all__ = ['Session', 'engine', 'metadata', 'mapper']

# SQLAlchemy database engine. Updated by model.init_model()
engine = None

if sqav.startswith("0.4"):
    # SQLAlchemy session manager. Updated by model.init_model()
    Session = scoped_session(sessionmaker(
        autoflush=False,
        transactional=True,
        extension=[CkanSessionExtension(),
                   extension.PluginSessionExtension()],
        ))
else:
    Session = scoped_session(sessionmaker(
        autoflush=False,
        autocommit=False,
        expire_on_commit=False,
        extension=[CkanSessionExtension(),
                   extension.PluginSessionExtension()],
        ))
Example #19
0
# fix up table dropping on postgres
# http://blog.pythonisito.com/2008/01/cascading-drop-table-with-sqlalchemy.html
from sqlalchemy import __version__ as sqav
if sqav[:3] in ("0.4", "0.5"):
     from sqlalchemy.databases import postgres
     class CascadeSchemaDropper(postgres.PGSchemaDropper):
          def visit_table(self, table):
               for column in table.columns:
                    if column.default is not None:
                         self.traverse_single(column.default)
               self.append("\nDROP TABLE " +
                           self.preparer.format_table(table) +
                           " CASCADE")
               self.execute()
     postgres.dialect.schemadropper = CascadeSchemaDropper
elif sqav.startswith("0.6") or sqav.startswith("0.7") or sqav.startswith("0.8"):
     from sqlalchemy.dialects.postgresql import base
     def visit_drop_table(self, drop):
          return "\nDROP TABLE " + \
                 self.preparer.format_table(drop.element) + \
                 " CASCADE"
     base.dialect.ddl_compiler.visit_drop_table = visit_drop_table
else:
     raise ValueError("VDM only works with SQLAlchemy versions 0.4 through 0.7, not: %s" % sqav)


from sqlalchemy import create_engine
try:
    from sqlalchemy.orm import ScopedSession as scoped_session
except ImportError:
    from sqlalchemy.orm import scoped_session
Example #20
0
from mongosql.handlers import MongoJoin
from tests.models import *

# Import both MongoSQL packages
try:
    from tests.benchmarks.mongosql_v1.mongosql import MongoQuery as MongoQuery_v1
except ImportError:
    print('Please install MongoSQL 1.5: ')
    print('$ bash tests/benchmarks/mongosql_v1_checkout.sh')
    exit(1)

from mongosql import MongoQuery as MongoQuery_v2

# Check SqlAlchemy version
from sqlalchemy import __version__ as SA_VERSION
assert SA_VERSION.startswith('1.2.'), 'Only works with SqlAlchemy 1.2.x'

# Init DB: choose one
engine, Session = get_working_db_for_tests()

# Prepare
N_REPEATS = 1000
MongoJoin.ENABLED_EXPERIMENTAL_SELECTINQUERY = False
ssn = Session()


# Tests
def test_v1(n):
    """ Test MongoSQL v1 """
    for i in range(n):
        q = MongoQuery_v1(User, query=ssn.query(User)).query(
from datetime import datetime
from functools import wraps
from typing import Any

from sqlalchemy import text  # type: ignore
from sqlalchemy.orm import Query  # type: ignore
from sqlalchemy import __version__


SQLALCHEMY_VERSION = __version__
IS_SQLALCHEMY_1_4 = __version__.startswith("1.4")


class Empty:
    pass


def get_sqlalchemy_version():
    return


def is_none(value: Any) -> bool:
    return isinstance(value, type(None))


def empty_sql():
    return text("")


def get_already_joined_tables(query: Query) -> list:
    if IS_SQLALCHEMY_1_4:
try:
    from sqlalchemy import create_engine, MetaData, Table, select, and_, __version__
except ImportError:
    print "SqlAlchemy was not found, please install it !"
    sys.exit(1)

def usage(argv):
    print >> sys.stderr, 'Usage: %s db_conn_string [--id entity_id|--name entity_name]' % argv[0]
    print >> sys.stderr, 'Where db_conn_string is a SQLAlchemy connection string, e.g. mysql://user:password@host/database'
    return 1

if __name__ == "__main__":
    if len(sys.argv) != 2 and len(sys.argv) != 4:
        sys.exit(usage(sys.argv))

    if not __version__.startswith('0.4'):
        print "Wrong version of SqlAlchemy found, please install a 0.4 version !"
        sys.exit(1)

    get_entity = False
    if len(sys.argv) == 4:
        if sys.argv[2] == '--id':
            id_entity = sys.argv[3]
            get_entity = True
        elif sys.argv[2] == '--name':
            id_entity = -1
            name_entity = sys.argv[3]
            get_entity = True
        else:
            print "dont know this option : %s" % sys.argv[2]
            sys.exit(1)
metadata.create_all(engine)

from sqlalchemy.orm import scoped_session, sessionmaker, create_session
from sqlalchemy.orm import relation, backref
SessionObject = scoped_session(create_session)
session = SessionObject()

from sqlalchemy.orm import mapper
#mapper = SessionObject.mapper

from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.orm.collections import attribute_mapped_collection

from sqlalchemy import __version__ as sqav
if sqav.startswith("0.4"):
    _clear = session.clear
else:
    _clear = session.expunge_all


class BaseObject(object):
    def __repr__(self):
        return '<%s %s>' % (self.__class__.__name__, self.id)


def delete(st):
    st.state = 'deleted'


def undelete(st):
Example #24
0
    filter: { age: { $gte: 18 } },  // filter: age >= 18
    join: ['user_profile'],  // load related `user_profile`
    limit: 10,  // limit to 10 rows
}))
```

Tired of adding query parameters for pagination, filtering, sorting?
Here is the ultimate solution.

NOTE: currently, only tested with PostgreSQL.
"""

# SqlAlchemy versions
from sqlalchemy import __version__ as SA_VERSION

SA_12 = SA_VERSION.startswith('1.2')
SA_13 = SA_VERSION.startswith('1.3')

# Exceptions that are used here and there
from .exc import *

# MongoSQL needs a lot of information about the properties of your models.
# All this is handled by the following class:
from .bag import ModelPropertyBags, CombinedBag

# The heart of MongoSql are the handlers:
# that's where your JSON objects are converted to actual SqlAlchemy queries!
from . import handlers

# MongoQuery is the man that parses your QueryObject and applies the methods from MongoModel that
# implement individual fields.