-SQLAlchemy README
-
-What is SQLAlchemy ?
----------------------
-
-SQLAlchemy is:
-
- - the Python SQL toolkit and Object Relational Mapper for
- application developers and programmers who require the full power of SQL.
-
- - a library that provides enterprise-level persistence patterns:
- eager loading of multiple types of objects using outer joins,
- Data Mapper, Unit of Work, all-or-nothing commits, bind parameters
- used for all literal values, batched updates and deletes.
-
- - a set of distinct tools that build upon each other. The lower level tools, such as
- the connection pool and its registry, can be used completely independently
- of the higher levels, such as data mapping. Higher levels always provide
- ways to affect and expose the lower levels, when customization is required.
-
- - extremely easy to use for basic tasks, such as: get a thread-safe and pooled
- connection to a database, perform SQL queries constructed from Python expressions,
- load a bunch of objects from the database, modify their data, and commit
- only everything that changed in one transaction-safe operation.
-
- - powerful enough to use for complicated tasks, such as: load objects and their child
- objects all in one query via eager loading, map objects to any
- SQL expression, combine multiple tables together to load whole sets of related or
- unrelated objects from any result set.
-
- - high performing, allowing pre-compilation of SQL queries, heavy usage of bind
- parameters which allow a database to cache its queries more effectively.
-
- - extensible. Query compilation, data mapping, the typing system, interaction
- with DBAPIs can be extended and augmented in many ways.
-
-SQLAlchemy's Philosophy:
-
- - A SQL database row and an object instance are not the same thing. A list
- of rows is not a table, and a table is not a class. The intricate relationships
- between objects and the rows that store them should be managed as automatically
- and as intelligently as possible, but always decoupled. An object need not
- have a row, a row need not have only one object. SQL databases behave less
- and less like object collections the more size and performance start to matter;
- object collections behave less and less like tables and rows the more abstraction
- starts to matter. SQLAlchemy aims to be ready for both.
-
-SQLAlchemy includes:
-
- - a connection pool, with the ability to transparently "wrap" any DBAPI module's
- connect() method into a thread-local and pooled resource.
-
- - Python function-based query construction. Allows not just straight boolean
- expressions, but also table aliases, selectable subqueries, create/update/insert/
- delete queries, correlated updates, correlated EXISTS clauses, UNION clauses, inner
- and outer joins, bind parameters, free mixing of literal text within expressions,
- as little or as much as desired. Query-compilation is vendor-specific; the same
- query object can be compiled into any number of resulting SQL strings depending
- on its compilation algorithm.
-
- - a table-meta-data description system, which can automatically load table data, or allow
- it to be described. Tables, foreign key constraints, and sequences can be created
- or dropped.
-
- - support for Postgres (psycopg1/2), Oracle (cx_Oracle), SQLite (pysqlite),
- MySQL (MySQLdb)
-
- - support for sequences to generate primary keys externally to the INSERT
- statement they apply to. Can be specified so that they
- transparently take effect only for databases that support them.
- Sequences, auto-incrementing columns, and explicit
- primary key attributes can be combined within one object.
-
- - a lastrowid accessor that returns an ordered array of all primary keys for the row
- just inserted, works identically across all databases, whether inserts are done
- via sequences, SERIAL, or autoincrements.
-
- - an Object Relational Mapper that supports the Data Mapper algorithm, objects
- created across multiple tables, lazy or eager loading of related objects.
-
- - an Identity Map, which stores a singleton instance of an object loaded from the
- database based on its key, or keys.
-
- - a Unit Of Work system which organizes pending CRUD operations into queues and
- commits them all in one batch. Performs a topological "dependency sort" of all
- items to be committed and deleted and groups redundant statements together.
- This produces the maxiumum efficiency and transaction safety, and minimizes
- chances of deadlocks. Modeled after Fowler's "Unit of Work" pattern as well as
- Java Hibernate.
-
- - optimistic "concurrency" checking built in - if an UPDATE or DELETE doesn't
- report the expected number of rows, an exception is thrown, the whole transaction
- is rolled back.
-
- - automatic thread-local operation for: pooled connections, identity maps,
- transactional contexts, units of work
-
- - can roll back object attributes to their pre-modified state.
-
-SQLAlchemy has the advantages:
-
- - database mapping and class design are totally separate. Persisted objects
- have no subclassing requirement (other than 'object') and are POPO's : plain
- old Python objects. They retain serializability (pickling) for usage in various
- caching systems and session objects. SQLAlchemy "decorates" classes
- with non-intrusive property accessors to automatically log object creates
- and modifications with the UnitOfWork engine, as well as track attribute
- histories.
-
- - Custom list classes can be used with eagerly or lazily loaded child object
- lists.
-
- - support for multiple primary keys, as well as support for "association"
- objects that represent the middle of a "many-to-many" relationship.
-
- - support for self-referential mappers. Adjacency list structures can be created,
- saved, and deleted with proper cascading, with no extra programming.
-
- - support for mapping objects from multiple tables, joins, and arbitrary
- select statements.
-
- - any number of mappers can be created for a particular class, for classes that
- are persisted in more than one way. Mappers can create copies of themselves
- with modified behavior, different combinations of lazy/eager loaded properties.
-
- - an extension interface allows mapping behavior to be augmented or replaced
- within all mapping functions.
-
- - data mapping can be used in a row-based manner. any bizarre hyper-optimized
- query that you or your DBA can cook up, you can run in SQLAlchemy, and as long as it
- returns the expected columns within a rowset, you can get your objects from it.
- For a rowset that contains more than one kind of object per row, multiple mappers
- can be chained together to return multiple object instance lists from a single
- database round trip.
-
- - all generated queries are compiled to use bind parameters for all literals.
- This way databases can maximally optimize query caching.
-
- - a type system that allows pre- and post- processing of data, both at the bind
- parameter and the result set level. User-defined types can be freely
- mixed with built-in types. Generic types as well as SQL-specific types
- are available.
-
SQLAlchemy is licensed under an MIT-style license (see LICENSE).
Other incorporated projects may be licensed under different licenses.
All licenses allow for non-commercial and commercial use.
python setup.py install
-
\ No newline at end of file
+good luck !
+
long_description = """\
SQLAlchemy is:
-- the Python SQL toolkit and Object Relational Mapper for application developers and programmers who want the full power and flexibility of SQL.
-
-- a library that provides enterprise-level persistence patterns: eager loading of multiple types of objects using outer joins, Data Mapper, Unit of Work, all-or-nothing commits, bind parameters used for all literal values, batched updates and deletes.
-
-- a set of distinct tools that build upon each other. The lower level tools, such as the connection pool, can be used completely independently of the higher levels, such as the data mapper. Higher levels always provide ways to affect and expose the lower levels, when customization is required.
-
-- extremely easy to use for basic tasks, such as: get a thread-safe and pooled connection to a database; execute SQL queries constructed from Python expressions, strings, or combinations of both; load a bunch of objects from the database, modify their data, and commit only everything that changed in one thread-safe operation.
-
-- powerful enough to use for complicated tasks, such as: load objects and their child objects all in one query via eager loading; map objects to arbitrary tables, joins and select statements; combine multiple tables together to load whole sets of related or unrelated objects from a single result set.
-
-- high performing, allowing pre-compilation of SQL queries, heavy usage of bind parameters which allow a database to cache its query plans more effectively.
-
-- extensible. Query compilation, data mapping, the typing system, interaction with DBAPIs can be extended and augmented in many ways.
+ * The Python SQL toolkit and Object Relational Mapper that gives application developers the full power and flexibility of SQL. SQLAlchemy provides a full suite of well known enterprise-level persistence patterns, designed for efficient and high-performing database access, adapted into a simple and Pythonic domain language.
+ * extremely easy to use for all the basic tasks, such as: accessing thread-safe and pooled connections, constructing SQL from Python expressions, finding object instances, and commiting object modifications back to the database.
+ * powerful enough for complicated tasks, such as: eager load a graph of objects and their dependencies via joins; map recursive adjacency structures automatically; map objects to not just tables but to any arbitrary join or select statement; combine multiple tables together to load whole sets of otherwise unrelated objects from a single result set; commit entire graphs of object changes in one step.
+ * built to conform to what DBAs demand, including the ability to swap out generated SQL with hand-optimized statements, full usage of bind parameters for all literal values, fully transactionalized and consistent updates using Unit of Work.
+ * modular. Different parts of SQLAlchemy can be used independently of the rest, including the connection pool, SQL construction, and ORM. SQLAlchemy is constructed in an open style that allows plenty of customization, with an architecture that supports custom datatypes, custom SQL extensions, and ORM plugins which can augment or extend mapping functionality.
SQLAlchemy's Philosophy:
-- SQL databases behave less and less like object collections the more size and performance start to matter; object collections behave less and less like tables and rows the more abstraction starts to matter. SQLAlchemy aims to accomodate both of these principles.
-
-SQLAlchemy includes:
-
-- a connection pool, with the ability to transparently "wrap" any DBAPI module's connect() method into a thread-local and pooled resource.
-
-- Python function-based query construction. Allows boolean expressions, operators, functions, table aliases, selectable subqueries, create/update/insert/delete queries, correlated updates, correlated EXISTS clauses, UNION clauses, inner and outer joins, bind parameters, free mixing of literal text within expressions, as little or as much as desired. Query-compilation is vendor-specific; the same query object can be compiled into any number of resulting SQL strings depending on its compilation algorithm.
-
-- a table metadata description system, which can automatically load table data, or allow it to be described. Tables, foreign key constraints, and sequences can be created or dropped.
-
-- support for Postgres (psycopg1/2), Oracle (cx_Oracle), SQLite (pysqlite), and MySQL (MySQLdb).
-
-- an Object Relational Mapper that supports the Data Mapper algorithm, objects created across multiple tables, lazy or eager loading of related objects.
-
-- a Unit Of Work system which organizes pending CRUD operations into queues and commits them all in one batch. Performs a topological "dependency sort" of all items to be committed and deleted and groups redundant statements together. This produces the maxiumum efficiency and transaction safety, and minimizes chances of deadlocks. Modeled after Fowler's "Unit of Work" pattern as well as Java Hibernate.
-
-- automatic thread-local operation for: pooled connections, object identity maps, transactional contexts, units of work
-
-SQLAlchemy has the advantages:
-
-- database mapping and class design are totally separate. Persisted objects have no subclassing requirement (other than 'object') and are POPO's : plain old Python objects. They retain serializability (pickling) for usage in various caching systems and session objects. SQLAlchemy "decorates" classes with non-intrusive property accessors to automatically log object creates and modifications with the UnitOfWork engine, to lazyload related data, as well as to track attribute change histories.
-
-- Custom list classes can be used with eagerly or lazily loaded child object lists, allowing rich relationships to be created on the fly as SQLAlchemy appends child objects to an object attribute.
-
-- support for multiple (composite) primary keys, as well as support for "association" objects that represent the middle of a "many-to-many" relationship.
-
-- support for self-referential mappers. Adjacency list structures can be created, saved, and deleted with proper cascading, with no extra programming.
-
-- support for mapping objects from multiple tables, joins, and arbitrary select statements.
-
-- any number of mappers can be created for a particular class, for classes that are persisted in more than one way. Mappers can create copies of themselves with modified behavior.
-
-- an extension interface allows mapping behavior to be augmented or replaced within all mapping functions.
-
-- data mapping can be used in a row-based manner. any bizarre hyper-optimized query that you or your DBA can cook up, you can run in SQLAlchemy, and as long as it returns the expected columns within a rowset, you can get your objects from it. For a rowset that contains more than one kind of object per row, multiple mappers can be chained together to return multiple object instance lists from a single database round trip.
-
-- all generated queries are compiled to use bind parameters for all literals. This way databases can maximally optimize the caching of compiled query plans. All DBAPI2 bind parameter schemes, named and positional, are supported. SQLAlchemy always works with named parameters on the interface side for consistency and convenience; named parameters are then converted to positional upon execution for those DBAPI implementations that require it.
+ * SQL databases behave less and less like object collections the more size and performance start to matter; object collections behave less and less like tables and rows the more abstraction starts to matter. SQLAlchemy aims to accomodate both of these principles.
+ * Your classes aren't tables, and your objects aren't rows. Databases aren't just collections of tables; they're relational algebra engines. You don't have to select from just tables, you can select from joins, subqueries, and unions. Database and domain concepts should be visibly decoupled from the beginning, allowing both sides to develop to their full potential.
+ * For example, table metadata (objects that describe tables) are declared distinctly from the classes theyre designed to store. That way database relationship concepts don't interfere with your object design concepts, and vice-versa; the transition from table-mapping to selectable-mapping is seamless; a class can be mapped against the database in more than one way. SQLAlchemy provides a powerful mapping layer that can work as automatically or as manually as you choose, determining relationships based on foreign keys or letting you define the join conditions explicitly, to bridge the gap between database and domain.
-- a type system that allows pre- and post- processing of data, both at the bind parameter and the result set level. User-defined types can be freely mixed with built-in types. Generic types as well as SQL-specific types are available.
+SQLAlchemy's Advantages:
-`Development SVN <http://svn.sqlalchemy.org/sqlalchemy/trunk#egg=sqlalchemy-dev>`_\
+ * The Unit Of Work system organizes pending CRUD operations into queues and commits them all in one batch. It then performs a topological "dependency sort" of all items to be committed and deleted and groups redundant statements together. This produces the maxiumum efficiency and transaction safety, and minimizes chances of deadlocks. Modeled after Fowler's "Unit of Work" pattern as well as Java Hibernate.
+ * Function-based query construction allows boolean expressions, operators, functions, table aliases, selectable subqueries, create/update/insert/delete queries, correlated updates, correlated EXISTS clauses, UNION clauses, inner and outer joins, bind parameters, free mixing of literal text within expressions, as little or as much as desired. Query-compilation is vendor-specific; the same query object can be compiled into any number of resulting SQL strings depending on its compilation algorithm.
+ * Database mapping and class design are totally separate. Persisted objects have no subclassing requirement (other than 'object') and are POPO's : plain old Python objects. They retain serializability (pickling) for usage in various caching systems and session objects. SQLAlchemy "decorates" classes with non-intrusive property accessors to automatically log object creates and modifications with the UnitOfWork engine, to lazyload related data, as well as to track attribute change histories.
+ * Custom list classes can be used with eagerly or lazily loaded child object lists, allowing rich relationships to be created on the fly as SQLAlchemy appends child objects to an object attribute.
+ * Composite (multiple-column) primary keys are supported, as are "association" objects that represent the middle of a "many-to-many" relationship.
+ * Self-referential tables and mappers are supported. Adjacency list structures can be created, saved, and deleted with proper cascading, with no extra programming.
+ * Data mapping can be used in a row-based manner. Any bizarre hyper-optimized query that you or your DBA can cook up, you can run in SQLAlchemy, and as long as it returns the expected columns within a rowset, you can get your objects from it. For a rowset that contains more than one kind of object per row, multiple mappers can be chained together to return multiple object instance lists from a single database round trip.
+ * The type system allows pre- and post- processing of data, both at the bind parameter and the result set level. User-defined types can be freely mixed with built-in types. Generic types as well as SQL-specific types are available.
""",
classifiers = [
"Development Status :: 3 - Alpha",
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
