File: PKG-INFO

package info (click to toggle)
sqlalchemy 1.3.22%2Bds1-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 16,916 kB
  • sloc: python: 263,220; ansic: 1,342; makefile: 255; xml: 17
file content (198 lines) | stat: -rw-r--r-- 8,554 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
Metadata-Version: 2.1
Name: SQLAlchemy
Version: 1.3.22
Summary: Database Abstraction Library
Home-page: http://www.sqlalchemy.org
Author: Mike Bayer
Author-email: mike_mp@zzzcomputing.com
License: MIT
Project-URL: Documentation, https://docs.sqlalchemy.org
Project-URL: Issue Tracker, https://github.com/sqlalchemy/sqlalchemy/
Description: SQLAlchemy
        ==========
        
        |PyPI| |Python| |Downloads|
        
        .. |PyPI| image:: https://img.shields.io/pypi/v/sqlalchemy
            :target: https://pypi.org/project/sqlalchemy
            :alt: PyPI
        
        .. |Python| image:: https://img.shields.io/pypi/pyversions/sqlalchemy
            :target: https://pypi.org/project/sqlalchemy
            :alt: PyPI - Python Version
        
        .. |Downloads| image:: https://img.shields.io/pypi/dm/sqlalchemy
            :target: https://pypi.org/project/sqlalchemy
            :alt: PyPI - Downloads
        
        
        The Python SQL Toolkit and Object Relational Mapper
        
        Introduction
        -------------
        
        SQLAlchemy is 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.
        
        Major SQLAlchemy features include:
        
        * An industrial strength ORM, built
          from the core on the identity map, unit of work,
          and data mapper patterns.   These patterns
          allow transparent persistence of objects
          using a declarative configuration system.
          Domain models
          can be constructed and manipulated naturally,
          and changes are synchronized with the
          current transaction automatically.
        * A relationally-oriented query system, exposing
          the full range of SQL's capabilities
          explicitly, including joins, subqueries,
          correlation, and most everything else,
          in terms of the object model.
          Writing queries with the ORM uses the same
          techniques of relational composition you use
          when writing SQL.  While you can drop into
          literal SQL at any time, it's virtually never
          needed.
        * A comprehensive and flexible system
          of eager loading for related collections and objects.
          Collections are cached within a session,
          and can be loaded on individual access, all
          at once using joins, or by query per collection
          across the full result set.
        * A Core SQL construction system and DBAPI
          interaction layer.  The SQLAlchemy Core is
          separate from the ORM and is a full database
          abstraction layer in its own right, and includes
          an extensible Python-based SQL expression
          language, schema metadata, connection pooling,
          type coercion, and custom types.
        * All primary and foreign key constraints are
          assumed to be composite and natural.  Surrogate
          integer primary keys are of course still the
          norm, but SQLAlchemy never assumes or hardcodes
          to this model.
        * Database introspection and generation.  Database
          schemas can be "reflected" in one step into
          Python structures representing database metadata;
          those same structures can then generate
          CREATE statements right back out - all within
          the Core, independent of the ORM.
        
        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 accommodate both of these
          principles.
        * An ORM doesn't need to hide the "R".   A relational
          database provides rich, set-based functionality
          that should be fully exposed.   SQLAlchemy's
          ORM provides an open-ended set of patterns
          that allow a developer to construct a custom
          mediation layer between a domain model and
          a relational schema, turning the so-called
          "object relational impedance" issue into
          a distant memory.
        * The developer, in all cases, makes all decisions
          regarding the design, structure, and naming conventions
          of both the object model as well as the relational
          schema.   SQLAlchemy only provides the means
          to automate the execution of these decisions.
        * With SQLAlchemy, there's no such thing as
          "the ORM generated a bad query" - you
          retain full control over the structure of
          queries, including how joins are organized,
          how subqueries and correlation is used, what
          columns are requested.  Everything SQLAlchemy
          does is ultimately the result of a developer-
          initiated decision.
        * Don't use an ORM if the problem doesn't need one.
          SQLAlchemy consists of a Core and separate ORM
          component.   The Core offers a full SQL expression
          language that allows Pythonic construction
          of SQL constructs that render directly to SQL
          strings for a target database, returning
          result sets that are essentially enhanced DBAPI
          cursors.
        * Transactions should be the norm.  With SQLAlchemy's
          ORM, nothing goes to permanent storage until
          commit() is called.  SQLAlchemy encourages applications
          to create a consistent means of delineating
          the start and end of a series of operations.
        * Never render a literal value in a SQL statement.
          Bound parameters are used to the greatest degree
          possible, allowing query optimizers to cache
          query plans effectively and making SQL injection
          attacks a non-issue.
        
        Documentation
        -------------
        
        Latest documentation is at:
        
        http://www.sqlalchemy.org/docs/
        
        Installation / Requirements
        ---------------------------
        
        Full documentation for installation is at
        `Installation <http://www.sqlalchemy.org/docs/intro.html#installation>`_.
        
        Getting Help / Development / Bug reporting
        ------------------------------------------
        
        Please refer to the `SQLAlchemy Community Guide <http://www.sqlalchemy.org/support.html>`_.
        
        Code of Conduct
        ---------------
        
        Above all, SQLAlchemy places great emphasis on polite, thoughtful, and
        constructive communication between users and developers.
        Please see our current Code of Conduct at
        `Code of Conduct <http://www.sqlalchemy.org/codeofconduct.html>`_.
        
        License
        -------
        
        SQLAlchemy is distributed under the `MIT license
        <http://www.opensource.org/licenses/mit-license.php>`_.
        
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Database :: Front-Ends
Classifier: Operating System :: OS Independent
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Provides-Extra: mysql
Provides-Extra: pymysql
Provides-Extra: postgresql
Provides-Extra: postgresql_psycopg2binary
Provides-Extra: postgresql_pg8000
Provides-Extra: postgresql_psycopg2cffi
Provides-Extra: oracle
Provides-Extra: mssql_pyodbc
Provides-Extra: mssql_pymssql
Provides-Extra: mssql