module.
"""
-from sqlalchemy import schema, sql, engine, util, sql_util, exceptions
+import string, re, sets, operator
+
+from sqlalchemy import schema, sql, engine, util, exceptions
from sqlalchemy.engine import default
-import string, re, sets, random, operator
ANSI_FUNCS = sets.ImmutableSet(['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
'CURRENT_USER', 'LOCALTIME', 'LOCALTIMESTAMP',
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-import sys, StringIO, string, types, warnings
+import warnings
from sqlalchemy import util, sql, schema, ansisql, exceptions
import sqlalchemy.engine.default as default
import sqlalchemy.sql as sql
-import sqlalchemy.engine as engine
-import sqlalchemy.schema as schema
-import sqlalchemy.ansisql as ansisql
-import sqlalchemy.types as sqltypes
import sqlalchemy.exceptions as exceptions
-from sqlalchemy import *
-from sqlalchemy.ansisql import *
+from sqlalchemy import select, MetaData, Table, Column, String, Integer
+from sqlalchemy.schema import PassiveDefault, ForeignKeyConstraint
ischema = MetaData()
-schemata = schema.Table("schemata", ischema,
+schemata = Table("schemata", ischema,
Column("catalog_name", String),
Column("schema_name", String),
Column("schema_owner", String),
schema="information_schema")
-tables = schema.Table("tables", ischema,
+tables = Table("tables", ischema,
Column("table_catalog", String),
Column("table_schema", String),
Column("table_name", String),
Column("table_type", String),
schema="information_schema")
-columns = schema.Table("columns", ischema,
+columns = Table("columns", ischema,
Column("table_schema", String),
Column("table_name", String),
Column("column_name", String),
Column("column_default", Integer),
schema="information_schema")
-constraints = schema.Table("table_constraints", ischema,
+constraints = Table("table_constraints", ischema,
Column("table_schema", String),
Column("table_name", String),
Column("constraint_name", String),
Column("constraint_type", String),
schema="information_schema")
-column_constraints = schema.Table("constraint_column_usage", ischema,
+column_constraints = Table("constraint_column_usage", ischema,
Column("table_schema", String),
Column("table_name", String),
Column("column_name", String),
Column("constraint_name", String),
schema="information_schema")
-pg_key_constraints = schema.Table("key_column_usage", ischema,
+pg_key_constraints = Table("key_column_usage", ischema,
Column("table_schema", String),
Column("table_name", String),
Column("column_name", String),
Column("ordinal_position", Integer),
schema="information_schema")
-#mysql_key_constraints = schema.Table("key_column_usage", ischema,
+#mysql_key_constraints = Table("key_column_usage", ischema,
# Column("table_schema", String),
# Column("table_name", String),
# Column("column_name", String),
key_constraints = pg_key_constraints
-ref_constraints = schema.Table("referential_constraints", ischema,
+ref_constraints = Table("referential_constraints", ischema,
Column("constraint_catalog", String),
Column("constraint_schema", String),
Column("constraint_name", String),
try:
gen_tbl = globals()['gen_'+name]
except KeyError:
- raise ArgumentError('information_schema table %s not found' % name)
+ raise exceptions.ArgumentError('information_schema table %s not found' % name)
self.cache[name] = gen_tbl.toengine(self.engine)
return self.cache[name]
colargs= []
if default is not None:
colargs.append(PassiveDefault(sql.text(default)))
- table.append_column(schema.Column(name, coltype, nullable=nullable, *colargs))
+ table.append_column(Column(name, coltype, nullable=nullable, *colargs))
if not found_table:
raise exceptions.NoSuchTableError(table.name)
if current_schema == referred_schema:
referred_schema = table.schema
if referred_schema is not None:
- schema.Table(referred_table, table.metadata, autoload=True, schema=referred_schema, autoload_with=connection)
+ Table(referred_table, table.metadata, autoload=True, schema=referred_schema, autoload_with=connection)
refspec = ".".join([referred_schema, referred_table, referred_column])
else:
- schema.Table(referred_table, table.metadata, autoload=True, autoload_with=connection)
+ Table(referred_table, table.metadata, autoload=True, autoload_with=connection)
refspec = ".".join([referred_table, referred_column])
if constrained_column not in fk[0]:
fk[0].append(constrained_column)
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
+import datetime, warnings
-import sys, StringIO, string , random, warnings
-import datetime
-from decimal import Decimal
-
-from sqlalchemy import util, sql, engine, schema, ansisql, exceptions, pool
+from sqlalchemy import sql, schema, ansisql, exceptions, pool
import sqlalchemy.engine.default as default
import sqlalchemy.types as sqltypes
except:
li = [ c for c in list.clauses ]
if list.parens:
- self.strings[list] = "(" + string.join([s for s in [self.strings[c] for c in li] if s is not None ], ', ') + ")"
+ self.strings[list] = "(" + ', '.join([s for s in [self.strings[c] for c in li] if s is not None ]) + ")"
else:
- self.strings[list] = string.join([s for s in [self.strings[c] for c in li] if s is not None], ', ')
+ self.strings[list] = ', '.join([s for s in [self.strings[c] for c in li] if s is not None])
class InfoSchemaGenerator(ansisql.ANSISchemaGenerator):
def get_column_specification(self, column, first_pk=False):
"""
-import sys, StringIO, string, types, re, datetime, random, warnings
+import datetime, random, warnings
-from sqlalchemy import sql, engine, schema, ansisql, exceptions
+from sqlalchemy import sql, schema, ansisql, exceptions
import sqlalchemy.types as sqltypes
from sqlalchemy.engine import default
def label_select_column(self, select, column):
if isinstance(column, sql._Function):
- return co.label(co.name + "_" + hex(random.randint(0, 65535))[2:])
+ return column.label(column.name + "_" + hex(random.randint(0, 65535))[2:])
else:
return super(MSSQLCompiler, self).label_select_column(select, column)
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-import sys, StringIO, string, re, warnings, operator
+import re, warnings, operator
-from sqlalchemy import util, sql, engine, schema, ansisql, exceptions, logging
+from sqlalchemy import util, sql, schema, ansisql, exceptions, logging
from sqlalchemy.engine import default, base
import sqlalchemy.types as sqltypes
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-import datetime, string, types, re, random, warnings, operator
+import re, random, warnings, operator
-from sqlalchemy import util, sql, schema, ansisql, exceptions
+from sqlalchemy import sql, schema, ansisql, exceptions
from sqlalchemy.engine import base, default
import sqlalchemy.types as sqltypes
from sqlalchemy.databases import information_schema as ischema
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-import sys, StringIO, string, types, re
+import re
-from sqlalchemy import sql, engine, schema, ansisql, exceptions, pool, PassiveDefault
+from sqlalchemy import schema, ansisql, exceptions, pool, PassiveDefault
import sqlalchemy.engine.default as default
import sqlalchemy.types as sqltypes
import datetime,time, warnings
from sqlalchemy import databases
from sqlalchemy.engine.base import *
from sqlalchemy.engine import strategies
-import re
def engine_descriptors():
"""Provide a listing of all the database implementations supported.
rec = (type, type.dialect_impl(self.dialect), i)
if rec[0] is None:
- raise DBAPIError("None for metadata " + colname)
+ raise exceptions.DBAPIError("None for metadata " + colname)
if self.__props.setdefault(colname.lower(), rec) is not rec:
self.__props[colname.lower()] = (type, ResultProxy.AmbiguousColumn(colname), 0)
self.__keys.append(colname)
"""Provide default implementations of per-dialect sqlalchemy.engine classes"""
-from sqlalchemy import schema, exceptions, util, sql, types
-import StringIO, sys, re
+from sqlalchemy import schema, exceptions, sql, types
+import sys, re
from sqlalchemy.engine import base
# to appropriate character upon compilation
self.positional = True
else:
- raise DBAPIError("Unsupported paramstyle '%s'" % self._paramstyle)
+ raise exceptions.DBAPIError("Unsupported paramstyle '%s'" % self._paramstyle)
def _get_ischema(self):
if self._ischema is None:
"""
-from sqlalchemy.engine import base, default, threadlocal, url
+from sqlalchemy.engine import base, threadlocal, url
from sqlalchemy import util, exceptions
from sqlalchemy import pool as poollib
def execute(self, object, *multiparams, **params):
raise NotImplementedError()
-MockEngineStrategy()
\ No newline at end of file
+MockEngineStrategy()
-from sqlalchemy import schema, exceptions, util, sql, types
-import StringIO, sys, re
-from sqlalchemy.engine import base, default
+from sqlalchemy import util
+from sqlalchemy.engine import base
"""Provide a thread-local transactional wrapper around the root Engine class.
-from sqlalchemy import join, ThreadLocalMetaData, util, Integer
-from sqlalchemy import and_, or_
+from sqlalchemy import ThreadLocalMetaData, util, Integer
from sqlalchemy import Table, Column, ForeignKey
-from sqlalchemy.orm import class_mapper, relation, mapper, create_session
+from sqlalchemy.orm import class_mapper, relation, create_session
from sqlalchemy.ext.sessioncontext import SessionContext
from sqlalchemy.ext.assignmapper import assign_mapper
from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.sessioncontext import SessionContext
-from sqlalchemy.ext.assignmapper import assign_mapper
from sqlalchemy.exceptions import *
-from sqlalchemy.ext.selectresults import *
+from sqlalchemy.ext.selectresults import SelectResultsExt
from sqlalchemy.orm.mapper import global_extensions
def install_plugin():
from sqlalchemy.orm.interfaces import SynonymProperty, MapperExtension, EXT_PASS, ExtensionOption
from sqlalchemy.orm.properties import PropertyLoader, ColumnProperty, CompositeProperty, BackRef
from sqlalchemy.orm import mapper as mapperlib
-from sqlalchemy.orm import collections
+from sqlalchemy.orm import collections, strategies
from sqlalchemy.orm.query import Query
from sqlalchemy.orm.util import polymorphic_union
from sqlalchemy.orm.session import Session as create_session
from sqlalchemy.orm.session import object_session, attribute_manager
-__all__ = ['relation', 'column_property', 'composite', 'backref', 'eagerload', 'lazyload', 'noload', 'deferred', 'defer', 'undefer', 'undefer_group', 'extension',
- 'mapper', 'clear_mappers', 'compile_mappers', 'class_mapper', 'object_mapper', 'MapperExtension', 'Query',
- 'polymorphic_union', 'create_session', 'synonym', 'contains_alias', 'contains_eager', 'EXT_PASS', 'object_session'
- ]
+__all__ = ['relation', 'column_property', 'composite', 'backref', 'eagerload',
+ 'lazyload', 'noload', 'deferred', 'defer', 'undefer',
+ 'undefer_group', 'extension', 'mapper', 'clear_mappers',
+ 'compile_mappers', 'class_mapper', 'object_mapper',
+ 'MapperExtension', 'Query', 'polymorphic_union', 'create_session',
+ 'synonym', 'contains_alias', 'contains_eager', 'EXT_PASS',
+ 'object_session'
+ ]
def relation(*args, **kwargs):
"""Provide a relationship of a primary Mapper to a secondary Mapper.
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-from sqlalchemy import util, sql
+import weakref
+
+from sqlalchemy import util
from sqlalchemy.orm import util as orm_util, interfaces, collections
from sqlalchemy.orm.mapper import class_mapper
from sqlalchemy import logging, exceptions
-import weakref
PASSIVE_NORESULT = object()
through the adapter, allowing for some very sophisticated behavior.
"""
+import copy, inspect, sys, weakref
+
from sqlalchemy import exceptions, schema, util as sautil
from sqlalchemy.orm import mapper
-import copy, sys, warnings, weakref
-import new
try:
from threading import Lock
executor = getattr(args[0], '_sa_adapter', None)
if before and executor:
- getattr(executor, op)(value, initiator)
+ getattr(executor, before)(value, initiator)
if not after or not executor:
return method(*args, **kw)
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-from sqlalchemy import sql, schema, util, exceptions, logging
+from sqlalchemy import sql, util, exceptions, logging
from sqlalchemy import sql_util as sqlutil
from sqlalchemy.orm import util as mapperutil
from sqlalchemy.orm.util import ExtensionCarrier
from sqlalchemy.orm import sync
-from sqlalchemy.orm.interfaces import MapperProperty, MapperOption, OperationContext, EXT_PASS, MapperExtension, SynonymProperty
+from sqlalchemy.orm.interfaces import MapperProperty, EXT_PASS, MapperExtension, SynonymProperty
import weakref, warnings, operator
__all__ = ['Mapper', 'class_mapper', 'object_mapper', 'mapper_registry']
# column
NO_ATTRIBUTE = object()
-
# lock used to synchronize the "mapper compile" step
_COMPILE_MUTEX = util.threading.Lock()
+# initialize these two lazily
+attribute_manager = None
+ColumnProperty = None
+
class Mapper(object):
"""Define the correlation of class attributes to database table
columns.
from sqlalchemy.orm import session as sessionlib
from sqlalchemy.orm import util as mapperutil
import operator
-from sqlalchemy.orm.interfaces import *
+from sqlalchemy.orm.interfaces import StrategizedProperty, PropComparator
__all__ = ['ColumnProperty', 'CompositeProperty', 'PropertyLoader', 'BackRef']
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-from sqlalchemy import sql, util, exceptions, sql_util, logging, schema
-from sqlalchemy.orm import mapper, class_mapper, object_mapper
+from sqlalchemy import sql, util, exceptions, sql_util, logging
+from sqlalchemy.orm import mapper, object_mapper
from sqlalchemy.orm.interfaces import OperationContext
import operator
__all__ = ['Query', 'QueryContext', 'SelectionContext']
class Query(object):
- """Encapsulates the object-fetching operations provided by Mappers.
+ """Encapsulates the object-fetching operations provided by Mappers."""
- """
-
def __init__(self, class_or_mapper, session=None, entity_name=None):
if isinstance(class_or_mapper, type):
self.mapper = mapper.class_mapper(class_or_mapper, entity_name=entity_name)
def filter_by(self, *args, **kwargs):
"""apply the given filtering criterion to the query and return the newly resulting ``Query``."""
- import properties
+ #import properties
if len(args) > 1:
raise exceptions.ArgumentError("filter_by() takes either zero positional arguments, or one scalar or list argument indicating a property search path.")
def execute(self, clauseelement, params=None, *args, **kwargs):
"""DEPRECATED. use query.from_statement().all()"""
- return self._select_statement(statement, params, **kwargs)
+ return self._select_statement(clauseelement, params, **kwargs)
def select_statement(self, statement, **params):
"""DEPRECATED. Use query.from_statement(statement)"""
def select_text(self, text, **params):
"""DEPRECATED. Use query.from_statement(statement)"""
- return self._select_statement(statement, params)
+ return self._select_statement(text, params)
def _select_statement(self, statement, params=None, **kwargs):
q = self.from_statement(statement)
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
+import weakref
+
from sqlalchemy import util, exceptions, sql, engine
-from sqlalchemy.orm import unitofwork, query
+from sqlalchemy.orm import unitofwork, query, util as mapperutil
from sqlalchemy.orm.mapper import object_mapper as _object_mapper
from sqlalchemy.orm.mapper import class_mapper as _class_mapper
-import weakref
-import sqlalchemy
class SessionTransaction(object):
"""Represents a Session-level Transaction.
return _sessions.get(hashkey)
return None
+# Lazy initialization to avoid circular imports
unitofwork.object_session = object_session
from sqlalchemy.orm import mapper
mapper.attribute_manager = attribute_manager
"""sqlalchemy.orm.interfaces.LoaderStrategy implementations, and related MapperOptions."""
-from sqlalchemy import sql, schema, util, exceptions, sql_util, logging
+from sqlalchemy import sql, util, exceptions, sql_util, logging
from sqlalchemy.orm import mapper, attributes
-from sqlalchemy.orm.interfaces import *
+from sqlalchemy.orm.interfaces import LoaderStrategy, StrategizedOption, MapperOption, PropertyOption
from sqlalchemy.orm import session as sessionlib
from sqlalchemy.orm import util as mapperutil
# determine if our "lazywhere" clause is the same as the mapper's
# get() clause. then we can just use mapper.get()
- from sqlalchemy.orm import query
+ #from sqlalchemy.orm import query
self.use_get = not self.uselist and self.mapper._get_clause.compare(self.lazywhere)
if self.use_get:
self.logger.info(str(self.parent_property) + " will use query.get() to optimize instance loads")
changes at once.
"""
-from sqlalchemy import util, logging, topological
+from sqlalchemy import util, logging, topological, exceptions
from sqlalchemy.orm import attributes, interfaces
from sqlalchemy.orm import util as mapperutil
-from sqlalchemy.orm.mapper import object_mapper, class_mapper
-from sqlalchemy.exceptions import *
+from sqlalchemy.orm.mapper import object_mapper
import StringIO
import weakref
+# Load lazily
+object_session = None
+
class UOWEventHandler(interfaces.AttributeExtension):
"""An event handler added to all class attributes which handles
session operations.
def _validate_obj(self, obj):
if (hasattr(obj, '_instance_key') and not self.identity_map.has_key(obj._instance_key)) or \
(not hasattr(obj, '_instance_key') and obj not in self.new):
- raise InvalidRequestError("Instance '%s' is not attached or pending within this session" % repr(obj))
+ raise exceptions.InvalidRequestError("Instance '%s' is not attached or pending within this session" % repr(obj))
def _is_valid(self, obj):
if (hasattr(obj, '_instance_key') and not self.identity_map.has_key(obj._instance_key)) or \
"""register the given object as 'new' (i.e. unsaved) within this unit of work."""
if hasattr(obj, '_instance_key'):
- raise InvalidRequestError("Object '%s' already has an identity - it can't be registered as new" % repr(obj))
+ raise exceptions.InvalidRequestError("Object '%s' already has an identity - it can't be registered as new" % repr(obj))
if obj not in self.new:
self.new.add(obj)
obj._sa_insert_order = len(self.new)
calling regular DBAPI connect() methods.
"""
-import weakref, string, time, sys, traceback
+import weakref, time
try:
import cPickle as pickle
except:
from sqlalchemy import sql, types, exceptions,util, databases
import sqlalchemy
-import copy, re, string
+import re, string
__all__ = ['SchemaItem', 'Table', 'Column', 'ForeignKey', 'Sequence', 'Index', 'ForeignKeyConstraint',
'PrimaryKeyConstraint', 'CheckConstraint', 'UniqueConstraint', 'DefaultGenerator', 'Constraint',
"""
-from sqlalchemy import util, exceptions, logging
+from sqlalchemy import util, exceptions
from sqlalchemy import types as sqltypes
-import string, re, sets, operator
+import re, operator
__all__ = ['AbstractDialect', 'Alias', 'ClauseElement', 'ClauseParameters',
'ClauseVisitor', 'ColumnCollection', 'ColumnElement',
return self.element,
def compare(self, other):
- """Compare this ``_UnaryClause`` against the given ``ClauseElement``."""
+ """Compare this ``_UnaryExpression`` against the given ``ClauseElement``."""
return (
- isinstance(other, _UnaryClause) and self.operator == other.operator and
+ isinstance(other, _UnaryExpression) and self.operator == other.operator and
self.modifier == other.modifier and
self.element.compare(other.element)
)
I realized this characteristic of the algorithm.
"""
-import string, StringIO
from sqlalchemy import util
from sqlalchemy.exceptions import CircularDependencyError
str(self.item) + \
(self.cycles is not None and (" (cycles: " + repr([x for x in self.cycles]) + ")") or "") + \
"\n" + \
- string.join([n.safestr(indent + 1) for n in self.children], '')
+ ''.join([n.safestr(indent + 1) for n in self.children])
def __repr__(self):
return "%s" % (str(self.item))
'SMALLINT', 'DATE', 'TIME','Interval'
]
-from sqlalchemy import util, exceptions
import inspect
import datetime as dt
try:
except:
import pickle
+from sqlalchemy import exceptions
+
class AbstractType(object):
def __init__(self, *args, **kwargs):
pass
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
