SQLAlchemy Example

API (Occurances)

lib.utils.sqlalchemy.SQLAlchemy(2)

flask_debugtoolbar.panels.sqlalchemy.SQLAlchemy(1)

flask.ext.sqlalchemy.SQLAlchemy(23)

flask.ext.sqlalchemy.SQLAlchemy.get_engine(1)

flask.ext.sqlalchemy.SQLAlchemy.create_all(1)

designate.sqlalchemy.base.SQLAlchemy._apply_criterion(7)

sqlalchemy.between(2)

mixer.backend.sqlalchemy.mixer.backend.sqlalchemy(9)

utils.SQLAlchemy(1)

sqlalchemy_wrapper.SQLAlchemy(80)

sqlalchemy.update.where(1)

sqlalchemy.update(18)

sqlalchemy.union_all(4)

sqlalchemy.union(21)

sqlalchemy.types(6)

sqlalchemy.type_coerce(3)

sqlalchemy.true(10)

sqlalchemy.text(160)

sqlalchemy.testing.against(10)

sqlalchemy.tablesample(1)

sqlalchemy.table(7)

sqlalchemy.sql_create_engine(1)

sqlalchemy.sqinspect(1)

sqlalchemy.select.where.where(6)

sqlalchemy.select.where(134)

sqlalchemy.select(159)

sqlalchemy.schema(2)

sqlalchemy.pool(5)

sqlalchemy.over.label(1)

sqlalchemy.outerjoin(2)

sqlalchemy.orm(10)

sqlalchemy.or_(189)

sqlalchemy.null(15)

sqlalchemy.not_(61)

sqlalchemy.literal_column(21)

sqlalchemy.literal(30)

sqlalchemy.lateral(3)

sqlalchemy.join(13)

sqlalchemy.intersect(4)

sqlalchemy.inspect(133)

sqlalchemy.insert(10)

sqlalchemy.func.any(1)

sqlalchemy.func(17)

sqlalchemy.false(1)

sqlalchemy.extract.between(1)

sqlalchemy.extract(26)

sqlalchemy.exists.where(7)

sqlalchemy.exists(1)

sqlalchemy.except_(4)

sqlalchemy.exc(3)

sqlalchemy.engine_from_config(111)

sqlalchemy.distinct(50)

sqlalchemy.desc(176)

sqlalchemy.delete.where.where.where.where(1)

sqlalchemy.delete.where.where(1)

sqlalchemy.delete.where(7)

sqlalchemy.delete(7)

sqlalchemy.create_engine(183)

sqlalchemy.column(13)

sqlalchemy.cast(53)

sqlalchemy.case(27)

sqlalchemy.boolean(1)

sqlalchemy.bindparam(85)

sqlalchemy.asc(49)

sqlalchemy.and_(183)

sqlalchemy.alias(7)

sqlalchemy._desc(1)

sqlalchemy.__version__(15)

sqlalchemy.VARCHAR(103)

sqlalchemy.VARBINARY(1)

sqlalchemy.UniqueConstraint(62)

sqlalchemy.UnicodeText(36)

sqlalchemy.Unicode(131)

sqlalchemy.TypeDecorator(1)

sqlalchemy.Text(137)

sqlalchemy.Table(166)

sqlalchemy.TIMESTAMP(4)

sqlalchemy.TIME(1)

sqlalchemy.TEXT(55)

sqlalchemy.String(190)

sqlalchemy.SmallInteger(6)

sqlalchemy.Sequence(30)

sqlalchemy.SMALLINT(1)

sqlalchemy.SAColumn(1)

sqlalchemy.REAL(4)

sqlalchemy.PrimaryKeyConstraint(17)

sqlalchemy.PickleType(7)

sqlalchemy.Numeric(31)

sqlalchemy.NVARCHAR(1)

sqlalchemy.NUMERIC(2)

sqlalchemy.NCHAR(1)

sqlalchemy.MetaData(185)

sqlalchemy.LargeBinary(3)

sqlalchemy.JSONEncodedDict(5)

sqlalchemy.Integer(185)

sqlalchemy.Index(112)

sqlalchemy.INTEGER(129)

sqlalchemy.INT(8)

sqlalchemy.GUID(54)

sqlalchemy.ForeignKeyConstraint(46)

sqlalchemy.ForeignKey(177)

sqlalchemy.Float(46)

sqlalchemy.FileStorage(1)

sqlalchemy.FetchedValue(2)

sqlalchemy.FLOAT(1)

sqlalchemy.Enum(61)

sqlalchemy.DefaultClause(3)

sqlalchemy.DateTime(175)

sqlalchemy.Date(26)

sqlalchemy.DECIMAL(2)

sqlalchemy.DDL(20)

sqlalchemy.DATETIME(8)

sqlalchemy.DATE(8)

sqlalchemy.ColumnDefault(1)

sqlalchemy.Column(184)

sqlalchemy.CheckConstraint(35)

sqlalchemy.CHAR(3)

sqlalchemy.Boolean(178)

sqlalchemy.Binary(1)

sqlalchemy.BigInteger(32)

sqlalchemy.BOOLEAN(31)

sqlalchemy.BLOB(1)

sqlalchemy.BINARY(3)

sqlalchemy.BIGINT(2)

flask_sqlalchemy.SQLAlchemy(51)

zope.sqlalchemy.register(3)

zope.sqlalchemy.mark_changed(7)

zope.sqlalchemy.ZopeTransactionExtension(37)

torext.sql.SQLAlchemy(1)

sqlalchemy.util.warn_limited(1)

sqlalchemy.util.warn_deprecated(4)

sqlalchemy.util.warn(42)

sqlalchemy.util.update_wrapper(3)

sqlalchemy.util.ue(6)

sqlalchemy.util.u(9)

sqlalchemy.util.to_tuple(6)

sqlalchemy.util.to_list(13)

sqlalchemy.util.text_type(11)

sqlalchemy.util.symbol(1)

sqlalchemy.util.string_types(5)

sqlalchemy.util.set_creation_order(5)

sqlalchemy.util.safe_reraise(1)

sqlalchemy.util.pypy(1)

sqlalchemy.util.py3k(4)

sqlalchemy.util.py2k(15)

sqlalchemy.util.populate_column_dict(2)

sqlalchemy.util.partial(1)

sqlalchemy.util.parse_qsl(2)

sqlalchemy.util.ordered_column_set(2)

sqlalchemy.util.methods_equivalent(2)

sqlalchemy.util.memoized_property(30)

sqlalchemy.util.get_cls_kwargs(7)

sqlalchemy.util.format_argspec_plus(1)

sqlalchemy.util.format_argspec_init(1)

sqlalchemy.util.flatten_iterator(1)

sqlalchemy.util.ellipses_string(1)

sqlalchemy.util.duck_type_collection(2)

sqlalchemy.util.deprecated(1)

sqlalchemy.util.defaultdict(17)

sqlalchemy.util.dedupe_tuple(1)

sqlalchemy.util.decorator(1)

sqlalchemy.util.column_set(3)

sqlalchemy.util.column_dict(6)

sqlalchemy.util.coerce_kw_type(13)

sqlalchemy.util.classproperty(2)

sqlalchemy.util.class_hierarchy(1)

sqlalchemy.util.chop_traceback(1)

sqlalchemy.util.callable(1)

sqlalchemy.util.bool_or_str(2)

sqlalchemy.util.b(1)

sqlalchemy.util.asbool(2)

sqlalchemy.util.as_interface(2)

sqlalchemy.util.ThreadLocalRegistry(2)

sqlalchemy.util.ScopedRegistry(2)

sqlalchemy.util.PopulateDict(1)

sqlalchemy.util.OrderedSet(7)

sqlalchemy.util.OrderedDict(25)

sqlalchemy.util.KeyedTuple(2)

sqlalchemy.util.IdentitySet(3)

sqlalchemy.update.where.where.where.values(1)

sqlalchemy.update.where.where.values(1)

sqlalchemy.update.where.values(2)

sqlalchemy.update.values.where(3)

sqlalchemy.update.values(1)

sqlalchemy.update.returning(2)

sqlalchemy.union_all.alias(1)

sqlalchemy.union.select(1)

sqlalchemy.union.order_by(2)

sqlalchemy.union.limit(4)

sqlalchemy.union.alias(2)

sqlalchemy.types.to_instance(3)

sqlalchemy.types.iteritems(2)

sqlalchemy.types.adapt_type(1)

sqlalchemy.types.Variant(1)

sqlalchemy.types.VARCHAR(6)

sqlalchemy.types.VARBINARY(2)

sqlalchemy.types.Unicode(13)

sqlalchemy.types.TypeEngine(6)

sqlalchemy.types.TypeDecorator(3)

sqlalchemy.types.Time(5)

sqlalchemy.types.Text(6)

sqlalchemy.types.TIMESTAMP(5)

sqlalchemy.types.TEXT(9)

sqlalchemy.types.String(73)

sqlalchemy.types.SMALLINT(1)

sqlalchemy.types.REAL(1)

sqlalchemy.types.PickleType(1)

sqlalchemy.types.Numeric(9)

sqlalchemy.types.NullType(5)

sqlalchemy.types.NUMERIC(8)

sqlalchemy.types.NULLTYPE(1)

sqlalchemy.types.LargeBinary(1)

sqlalchemy.types.Integer(53)

sqlalchemy.types.INT(1)

sqlalchemy.types.Float(3)

sqlalchemy.types.Enum(12)

sqlalchemy.types.DateTime(15)

sqlalchemy.types.Date(8)

sqlalchemy.types.DECIMAL(3)

sqlalchemy.types.DATETIME(1)

sqlalchemy.types.DATE(2)

sqlalchemy.types.CHAR(6)

sqlalchemy.types.Boolean(10)

sqlalchemy.types.BigInteger(2)

sqlalchemy.types.BOOLEAN(1)

sqlalchemy.types.BLOB(5)

sqlalchemy.types.BINARY(5)

sqlalchemy.tuple_.in_(2)

sqlalchemy.topological.sort_as_subsets(1)

sqlalchemy.topological.sort(1)

sqlalchemy.topological.find_cycles(1)

sqlalchemy.tickets.find_one(1)

sqlalchemy.text.params(5)

sqlalchemy.text.execution_options(1)

sqlalchemy.text.columns(10)

sqlalchemy.text.bindparams(23)

sqlalchemy.testing.uses_deprecated(8)

sqlalchemy.testing.skip_if(6)

sqlalchemy.testing.requires(1)

sqlalchemy.testing.provide_metadata(99)

sqlalchemy.testing.only_on(18)

sqlalchemy.testing.only_if(2)

sqlalchemy.testing.not_in_(2)

sqlalchemy.testing.ne_(8)

sqlalchemy.testing.mock.ANY(1)

sqlalchemy.testing.is_true(5)

sqlalchemy.testing.is_not_(5)

sqlalchemy.testing.is_false(6)

sqlalchemy.testing.is_(89)

sqlalchemy.testing.in_(3)

sqlalchemy.testing.force_drop_names(3)

sqlalchemy.testing.fails_on_everything_except(5)

sqlalchemy.testing.fails_on(25)

sqlalchemy.testing.fails_if(10)

sqlalchemy.testing.expect_warnings(17)

sqlalchemy.testing.expect_deprecated(2)

sqlalchemy.testing.exclusions.against(10)

sqlalchemy.testing.exclude(6)

sqlalchemy.testing.eq_regex(3)

sqlalchemy.testing.eq_(170)

sqlalchemy.testing.emits_warning_on(10)

sqlalchemy.testing.emits_warning(10)

sqlalchemy.testing.db(195)

sqlalchemy.testing.crashes(7)

sqlalchemy.testing.assert_warnings(6)

sqlalchemy.testing.assert_raises_message(143)

sqlalchemy.testing.assert_raises(71)

sqlalchemy.testing._is_excluded(1)

sqlalchemy.table.insert(1)

sqlalchemy.sqltypes.to_instance(11)

sqlalchemy.sqltypes.adapt_type(1)

sqlalchemy.sqltypes.VARCHAR(3)

sqlalchemy.sqltypes.Unicode(11)

sqlalchemy.sqltypes.TypeEngine(2)

sqlalchemy.sqltypes.TypeDecorator(1)

sqlalchemy.sqltypes.String(7)

sqlalchemy.sqltypes.SmallInteger(1)

sqlalchemy.sqltypes.SchemaType(1)

sqlalchemy.sqltypes.Numeric(3)

sqlalchemy.sqltypes.NullType(5)

sqlalchemy.sqltypes.NULLTYPE(16)

sqlalchemy.sqltypes.JSON(1)

sqlalchemy.sqltypes.Interval(4)

sqlalchemy.sqltypes.Integer(18)

sqlalchemy.sqltypes.Enum(1)

sqlalchemy.sqltypes.DateTime(2)

sqlalchemy.sqltypes.Date(2)

sqlalchemy.sqltypes.DATE(3)

sqlalchemy.sqltypes.Boolean(13)

sqlalchemy.sqlautil.OrderedSet(1)

sqlalchemy.sqlalchemy_exc.StatementError(1)

sqlalchemy.sqlalchemy_exc.InvalidRequestError(1)

sqlalchemy.sqla_types.Integer(4)

sqlalchemy.sqla_schema.Column(1)

sqlalchemy.sqla_queue.Queue(1)

sqlalchemy.sqla_queue.Full(1)

sqlalchemy.sqla_queue.Empty(2)

sqlalchemy.sqla_fn.greatest(1)

sqlalchemy.sqla_fn.ST_GeomFromGeoJSON(1)

sqlalchemy.sqla_exc.SQLAlchemyError(7)

sqlalchemy.sqla_exc.ProgrammingError(1)

sqlalchemy.sqla_exc.OperationalError(12)

sqlalchemy.sqla_exc.InvalidRequestError(1)

sqlalchemy.sqla_exc.InternalError(1)

sqlalchemy.sqla_exc.IntegrityError(6)

sqlalchemy.sqla_exc.DisconnectionError(2)

sqlalchemy.sqla_exc.DBAPIError(2)

sqlalchemy.sqla_event.listens_for(21)

sqlalchemy.sql_types.String(1)

sqlalchemy.sql_types.Numeric(2)

sqlalchemy.sql_types.Date(2)

sqlalchemy.sql_schema._get_table_key(1)

sqlalchemy.sql_schema.PrimaryKeyConstraint(1)

sqlalchemy.sql_func.sum(3)

sqlalchemy.sql_func.lower(3)

sqlalchemy.sql_func.count(6)

sqlalchemy.sql_exc.OperationalError(1)

sqlalchemy.sql_exc.IntegrityError(5)

sqlalchemy.sql.update(6)

sqlalchemy.sql.union_all(1)

sqlalchemy.sql.true(4)

sqlalchemy.sql.text(163)

sqlalchemy.sql.table(128)

sqlalchemy.sql.sqltext(5)

sqlalchemy.sql.select.where.where.where.where(2)

sqlalchemy.sql.select.where.where.where(2)

sqlalchemy.sql.select.where.where(2)

sqlalchemy.sql.select.where(70)

sqlalchemy.sql.select(146)

sqlalchemy.sql.outparam(4)

sqlalchemy.sql.or_(53)

sqlalchemy.sql.null(8)

sqlalchemy.sql.not_(23)

sqlalchemy.sql.literal_column(4)

sqlalchemy.sql.literal(14)

sqlalchemy.sql.join(5)

sqlalchemy.sql.insert(6)

sqlalchemy.sql.functions(1)

sqlalchemy.sql.func(6)

sqlalchemy.sql.false(12)

sqlalchemy.sql.expression.between(5)

sqlalchemy.sql.expression(1)

sqlalchemy.sql.exists.where(12)

sqlalchemy.sql.exists(3)

sqlalchemy.sql.distinct(2)

sqlalchemy.sql.desc(12)

sqlalchemy.sql.delete.where(3)

sqlalchemy.sql.delete(1)

sqlalchemy.sql.column(175)

sqlalchemy.sql.cast(5)

sqlalchemy.sql.case(3)

sqlalchemy.sql.bindparam(23)

sqlalchemy.sql.asc(2)

sqlalchemy.sql.and_(171)

sqlalchemy.sql.alias(2)

sqlalchemy.sql.Selectable(3)

sqlalchemy.sql.Select(7)

sqlalchemy.sql.Join(1)

sqlalchemy.sql.FromClause(1)

sqlalchemy.sql.FALSE(1)

sqlalchemy.sql.ColumnElement(5)

sqlalchemy.sql.ClauseVisitor(1)

sqlalchemy.sql.ClauseElement(2)

sqlalchemy.sql.Alias(2)

sqlalchemy.sqinspect.primary_key(1)

sqlalchemy.select.with_for_update.where(1)

sqlalchemy.select.where.where.where.count(1)

sqlalchemy.select.where.where.label(4)

sqlalchemy.select.where.where.count(2)

sqlalchemy.select.where.order_by(10)

sqlalchemy.select.where.group_by(1)

sqlalchemy.select.where.distinct(1)

sqlalchemy.select.where.cte(1)

sqlalchemy.select.where.as_scalar(3)

sqlalchemy.select.where.alias(2)

sqlalchemy.select.union(1)

sqlalchemy.select.select_from.where(10)

sqlalchemy.select.select_from(20)

sqlalchemy.select.scalar(2)

sqlalchemy.select.order_by(15)

sqlalchemy.select.offset(1)

sqlalchemy.select.limit.where(1)

sqlalchemy.select.limit(3)

sqlalchemy.select.group_by.having(1)

sqlalchemy.select.group_by(7)

sqlalchemy.select.execution_options(4)

sqlalchemy.select.execute(4)

sqlalchemy.select.distinct(2)

sqlalchemy.select.compile(3)

sqlalchemy.select.as_scalar(7)

sqlalchemy.select.apply_labels(4)

sqlalchemy.select.alias(18)

sqlalchemy.schema.encode(3)

sqlalchemy.schema.decode(2)

sqlalchemy.schema._get_table_key(1)

sqlalchemy.schema.UniqueConstraint(18)

sqlalchemy.schema.Table(67)

sqlalchemy.schema.SqlaTable(1)

sqlalchemy.schema.Sequence(19)

sqlalchemy.schema.SQLATable(3)

sqlalchemy.schema.MetaData(72)

sqlalchemy.schema.Index(30)

sqlalchemy.schema.ForeignKeyConstraint(17)

sqlalchemy.schema.ForeignKey(18)

sqlalchemy.schema.FetchedValue(3)

sqlalchemy.schema.DropTable(26)

sqlalchemy.schema.DropSequence(2)

sqlalchemy.schema.DropIndex(6)

sqlalchemy.schema.DropConstraint(22)

sqlalchemy.schema.DefaultClause(8)

sqlalchemy.schema.DDLElement(1)

sqlalchemy.schema.DDL(18)

sqlalchemy.schema.CreateTable(72)

sqlalchemy.schema.CreateSequence(2)

sqlalchemy.schema.CreateSchema(1)

sqlalchemy.schema.CreateIndex(27)

sqlalchemy.schema.CreateColumn(1)

sqlalchemy.schema.ColumnDefault(5)

sqlalchemy.schema.Column(64)

sqlalchemy.schema.CheckConstraint(5)

sqlalchemy.schema.AddConstraint(17)

sqlalchemy.sat.SmallInteger(1)

sqlalchemy.sa_sql.select(4)

sqlalchemy.sa_schema._get_table_key(2)

sqlalchemy.sa_schema.UniqueConstraint(5)

sqlalchemy.sa_schema.Table(4)

sqlalchemy.sa_schema.Sequence(4)

sqlalchemy.sa_schema.PrimaryKeyConstraint(5)

sqlalchemy.sa_schema.MetaData(2)

sqlalchemy.sa_schema.Index(2)

sqlalchemy.sa_schema.ForeignKeyConstraint(5)

sqlalchemy.sa_schema.DefaultClause(5)

sqlalchemy.sa_schema.Column(13)

sqlalchemy.sa_schema.CheckConstraint(1)

sqlalchemy.sa_pool.NullPool(1)

sqlalchemy.sa_exceptions.IntegrityError(2)

sqlalchemy.sa_exceptions.DatabaseError(1)

sqlalchemy.sa_exc.UnboundExecutionError(2)

sqlalchemy.sa_exc.SQLAlchemyError(5)

sqlalchemy.sa_exc.SAWarning(2)

sqlalchemy.sa_exc.SAPendingDeprecationWarning(5)

sqlalchemy.sa_exc.SADeprecationWarning(2)

sqlalchemy.sa_exc.ResourceClosedError(1)

sqlalchemy.sa_exc.OperationalError(3)

sqlalchemy.sa_exc.NoSuchTableError(1)

sqlalchemy.sa_exc.NoInspectionAvailable(1)

sqlalchemy.sa_exc.InvalidRequestError(20)

sqlalchemy.sa_exc.IntegrityError(1)

sqlalchemy.sa_exc.DisconnectionError(1)

sqlalchemy.sa_exc.DBAPIError(12)

sqlalchemy.sa_exc.ArgumentError(12)

sqlalchemy.sa_ex.InvalidRequestError(2)

sqlalchemy.sa_event.listens_for(1)

sqlalchemy.sa_event.listen(1)

sqlalchemy.processors.to_unicode_processor_factory(2)

sqlalchemy.processors.to_str(2)

sqlalchemy.processors.to_float(9)

sqlalchemy.processors.to_decimal_processor_factory(4)

sqlalchemy.processors.str_to_datetime_processor_factory(3)

sqlalchemy.processors.boolean_to_int(6)

sqlalchemy.poollib._DBProxy(4)

sqlalchemy.poollib.QueuePool(1)

sqlalchemy.pool.reset_rollback(2)

sqlalchemy.pool.manage(4)

sqlalchemy.pool.get_pool(5)

sqlalchemy.pool.connect(3)

sqlalchemy.pool._refs(3)

sqlalchemy.pool._invalidate_time(3)

sqlalchemy.pool.StaticPool(4)

sqlalchemy.pool.SingletonThreadPool(3)

sqlalchemy.pool.QueuePool(8)

sqlalchemy.pool.NullPool(66)

sqlalchemy.pool.AssertionPool(2)

sqlalchemy.orm.with_polymorphic(28)

sqlalchemy.orm.was_deleted(1)

sqlalchemy.orm.validates(8)

sqlalchemy.orm.undefer_group(19)

sqlalchemy.orm.undefer(47)

sqlalchemy.orm.synonym(20)

sqlalchemy.orm.subqueryload_all(16)

sqlalchemy.orm.subqueryload(96)

sqlalchemy.orm.state(1)

sqlalchemy.orm.sqla_mapper(1)

sqlalchemy.orm.sessionmaker(190)

sqlalchemy.orm.scoped_session(129)

sqlalchemy.orm.remote(5)

sqlalchemy.orm.relationship(172)

sqlalchemy.orm.relation(17)

sqlalchemy.orm.reconstructor(6)

sqlalchemy.orm.polymorphic_union(1)

sqlalchemy.orm.object_session(85)

sqlalchemy.orm.object_mapper(14)

sqlalchemy.orm.noload(16)

sqlalchemy.orm.mapper(165)

sqlalchemy.orm.make_transient(6)

sqlalchemy.orm.load_only(47)

sqlalchemy.orm.lazyload(24)

sqlalchemy.orm.joinedload_all(44)

sqlalchemy.orm.joinedload(180)

sqlalchemy.orm.join(2)