def normalize_url(raw): """ Build a URL from a string according to obvious rules. Converts *.sqlite paths to sqlite:/// URLs, etc. >>> str(normalize_url("/tmp/foo.sqlite")) 'sqlite:////tmp/foo.sqlite' >>> str(normalize_url("postgresql://user@host/database")) 'postgresql://user@host/database' """ from sqlalchemy.engine.url import make_url from sqlalchemy.exceptions import ArgumentError try: return make_url(raw) except ArgumentError: from os.path import ( abspath, splitext, ) (root, extension) = splitext(raw) if extension == ".sqlite": return make_url("sqlite:///%s" % abspath(raw)) else: raise ArgumentError("could not parse supposed URL \"%s\"" % raw)
def __init__(self, engine_or_metadata, base=object, session=None): """Initialize a new :class:`.SqlSoup`. :param engine_or_metadata: a string database URL, :class:`.Engine` or :class:`.MetaData` object to associate with. If the argument is a :class:`.MetaData`, it should be *bound* to an :class:`.Engine`. :param base: a class which will serve as the default class for returned mapped classes. Defaults to ``object``. :param session: a :class:`.ScopedSession` or :class:`.Session` with which to associate ORM operations for this :class:`.SqlSoup` instance. If ``None``, a :class:`.ScopedSession` that's local to this module is used. """ self.session = session or Session self.base = base if isinstance(engine_or_metadata, MetaData): self._metadata = engine_or_metadata elif isinstance(engine_or_metadata, (basestring, Engine)): self._metadata = MetaData(engine_or_metadata) else: raise ArgumentError("invalid engine or metadata argument %r" % engine_or_metadata) self._cache = {} self.schema = None
def __init__(self, *columns, **kwargs): """The list of `columns` describes a single object property. If there are multiple tables joined together for the mapper, this list represents the equivalent column as it appears across each table. """ self.columns = list(columns) self.group = kwargs.pop('group', None) self.deferred = kwargs.pop('deferred', False) self.comparator = ColumnProperty.ColumnComparator(self) # sanity check for col in columns: if not hasattr(col, 'name'): if hasattr(col, 'label'): raise ArgumentError( 'ColumnProperties must be named for the mapper to work with them. Try .label() to fix this' ) raise ArgumentError( '%r is not a valid candidate for ColumnProperty' % col)
def __init__(self, *columns, **kwargs): """The list of `columns` describes a single object property. If there are multiple tables joined together for the mapper, this list represents the equivalent column as it appears across each table. """ self.columns = list(columns) self.group = kwargs.pop('group', None) self.deferred = kwargs.pop('deferred', False) self.comparator = ColumnProperty.ColumnComparator(self) if self.deferred: self.strategy_class = strategies.DeferredColumnLoader else: self.strategy_class = strategies.ColumnLoader # sanity check for col in columns: if not isinstance(col, ColumnElement): raise ArgumentError('column_property() must be given a ColumnElement as its argument. Try .label() or .as_scalar() for Selectables to fix this.')
def __init__(self, engine_or_metadata, base=object, **kw): """Initialize a new ``SqlSoup``. `base` is the class that all created entity classes should subclass. `args` may either be an ``SQLEngine`` or a set of arguments suitable for passing to ``create_engine``. """ self.session = kw.pop('session', Session) self.base = base if isinstance(engine_or_metadata, MetaData): self._metadata = engine_or_metadata elif isinstance(engine_or_metadata, (basestring, Engine)): self._metadata = MetaData(engine_or_metadata) else: raise ArgumentError("invalid engine or metadata argument %r" % engine_or_metadata) self._cache = {} self.schema = None
def map_to(self, attrname, tablename=None, selectable=None, schema=None, base=None, mapper_args=util.frozendict()): """Configure a mapping to the given attrname. This is the "master" method that can be used to create any configuration. (new in 0.6.6) :param attrname: String attribute name which will be established as an attribute on this :class:.`.SqlSoup` instance. :param base: a Python class which will be used as the base for the mapped class. If ``None``, the "base" argument specified by this :class:`.SqlSoup` instance's constructor will be used, which defaults to ``object``. :param mapper_args: Dictionary of arguments which will be passed directly to :func:`.orm.mapper`. :param tablename: String name of a :class:`.Table` to be reflected. If a :class:`.Table` is already available, use the ``selectable`` argument. This argument is mutually exclusive versus the ``selectable`` argument. :param selectable: a :class:`.Table`, :class:`.Join`, or :class:`.Select` object which will be mapped. This argument is mutually exclusive versus the ``tablename`` argument. :param schema: String schema name to use if the ``tablename`` argument is present. """ if attrname in self._cache: raise InvalidRequestError( "Attribute '%s' is already mapped to '%s'" % (attrname, class_mapper(self._cache[attrname]).mapped_table)) if tablename is not None: if not isinstance(tablename, basestring): raise ArgumentError("'tablename' argument must be a string.") if selectable is not None: raise ArgumentError("'tablename' and 'selectable' " "arguments are mutually exclusive") selectable = Table(tablename, self._metadata, autoload=True, autoload_with=self.bind, schema=schema or self.schema) elif schema: raise ArgumentError("'tablename' argument is required when " "using 'schema'.") elif selectable is not None: if not isinstance(selectable, expression.FromClause): raise ArgumentError("'selectable' argument must be a " "table, select, join, or other " "selectable construct.") else: raise ArgumentError("'tablename' or 'selectable' argument is " "required.") if not selectable.primary_key.columns: if tablename: raise PKNotFoundError("table '%s' does not have a primary " "key defined" % tablename) else: raise PKNotFoundError( "selectable '%s' does not have a primary " "key defined" % selectable) mapped_cls = _class_for_table(self.session, self.engine, selectable, base or self.base, mapper_args) self._cache[attrname] = mapped_cls return mapped_cls