SQLObject-3.1.0/0000755000175000017500000000000012754657361012671 5ustar phdphd00000000000000SQLObject-3.1.0/setup.cfg0000644000175000017500000000236612754657361014521 0ustar phdphd00000000000000[global] command_packages = buildutils.pudge_command, buildutils.publish_command [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 [flake8] exclude = .git,docs/europython/*.py,ez_setup.py ignore = E401 [pudge] theme = pythonpaste.org docs = docs/index.rst docs/Authors.rst docs/DeveloperGuide.rst docs/FAQ.rst docs/Inheritance.rst docs/News.rst docs/News1.rst docs/News2.rst docs/News3.rst docs/News4.rst docs/News5.rst docs/Python3.rst docs/SQLBuilder.rst docs/SQLObject.rst docs/SelectResults.rst docs/TODO.rst docs/Versioning.rst docs/Views.rst docs/community.rst docs/download.rst docs/links.rst docs/sqlobject-admin.rst doc_base = docs/ dest = docs/html modules = sqlobject exclude_modules = sqlobject.conftest sqlobject.tests sqlobject.inheritance.tests sqlobject.versioning.test sqlobject.wsgi_middleware title = SQLObject mailing_list_url = community.html settings = normal_link_color=#039 visited_color=#093 hover_color=#ddf body_outer_bg_color=#46a body_border_color=#09f nav_container_color=#79f nav_button_color=#037 nav_border_color=#05f no_about=true link1=SQLObject.html Documentation [publish] doc-dir = docs/html make-dirs = 1 doc-dest = scp://web.sourceforge.net:/home/project-web/sqlobject/ [bdist_wheel] universal = 1 SQLObject-3.1.0/scripts/0000755000175000017500000000000012754657361014360 5ustar phdphd00000000000000SQLObject-3.1.0/scripts/sqlobject-admin0000755000175000017500000000177112475125544017361 0ustar phdphd00000000000000#!/usr/bin/env python from __future__ import print_function import sys import os try: import pkg_resources pkg_resources.require('SQLObject>0.6.1') except (ImportError, pkg_resources.DistributionNotFound): # Oh well, we tried... pass try: import sqlobject.manager except ImportError: try: here = __file__ except NameError: here = sys.argv[0] updir = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(here))), 'sqlobject') if os.path.exists(updir): sys.path.insert(0, os.path.dirname(updir)) else: print('I cannot find the sqlobject module') print('If SQLObject is installed, you may need to set $PYTHONPATH') sys.exit(3) # Now we have to get rid of possibly stale modules from that import # up there for name, value in sys.modules.items(): if name.startswith('sqlobject'): del sys.modules[name] from sqlobject.manager import command command.the_runner.run(sys.argv) SQLObject-3.1.0/scripts/sqlobject-convertOldURI0000755000175000017500000000064112475125544020763 0ustar phdphd00000000000000#!/usr/bin/env python from __future__ import print_function import sys try: uri = sys.argv[1] except IndexError: sys.exit("Usage: %s old-style-URI" % sys.argv[0]) try: import pkg_resources pkg_resources.require('SQLObject>=1.0.0') except (ImportError, pkg_resources.DistributionNotFound): pass from sqlobject import connectionForURI conn = connectionForURI(uri, oldUri=True) print(conn.uri()) SQLObject-3.1.0/README.rst0000644000175000017500000000102212754656750014354 0ustar phdphd00000000000000SQLObject 3.1.0 =============== Thanks for looking at SQLObject. SQLObject is an object-relational mapper, i.e., a library that will wrap your database tables in Python classes, and your rows in Python instances. It currently supports MySQL through the `MySQLdb` package, PostgreSQL through the `psycopg` package, SQLite, Firebird, MaxDB (SAP DB), MS SQL Sybase and Rdbhost. Python 2.6, 2.7 or 3.4+ is required. For more information please see the documentation in ``_, or online at http://sqlobject.org/ SQLObject-3.1.0/tox.ini0000644000175000017500000000403112753127445014174 0ustar phdphd00000000000000[tox] minversion = 1.8 envlist = {py26,py27}-mysql,{py26,py27,py34}-postgres,{py26,py27,py34}-sqlite,{py27,py34}-flake8,py34-mysqlclient # Base test environment settings [testenv] # Don't fail or warn on uninstalled commands whitelist_externals = mysql psql # Ensure we cd into sqlobject before running the tests changedir = ./sqlobject/ basepython = py26: python2.6 py27: python2.7 py34: python3.4 deps = pytest pytest-cov py26,py27: FormEncode >= 1.1.1, != 1.3.0 py34: FormEncode >= 1.3.1 PyDispatcher>=2.0.4 mysql: mysql-python mysqlclient: mysqlclient postgres: psycopg2 passenv = CI TRAVIS TRAVIS_* # MySQL test environments [mysql] commands = mysql -e 'create database sqlobject_test;' py.test --cov=sqlobject -D mysql://root:@localhost/sqlobject_test mysql -e 'drop database sqlobject_test;' [testenv:py26-mysql] commands = {[mysql]commands} [testenv:py27-mysql] commands = {[mysql]commands} # PostgreSQL test environments [postgresql] commands = psql -c 'create database sqlobject_test;' -U postgres py.test --cov=sqlobject -D postgres://postgres:@localhost/sqlobject_test psql -c 'drop database sqlobject_test;' -U postgres [testenv:py26-postgres] commands = {[postgresql]commands} [testenv:py27-postgres] commands = {[postgresql]commands} [testenv:py34-postgres] commands = {[postgresql]commands} # SQLite test environments [sqlite] commands = py.test --cov=sqlobject -D sqlite:///tmp/sqlobject_test.sqdb [testenv:py26-sqlite] commands = {[sqlite]commands} [testenv:py27-sqlite] commands = {[sqlite]commands} [testenv:py34-sqlite] commands = {[sqlite]commands} # Special test environments [testenv:py34-mysqlclient] commands = mysql -e 'create database sqlobject_test;' py.test --cov=sqlobject -D mysql://root:@localhost/sqlobject_test?charset=utf8 mysql -e 'drop database sqlobject_test;' [testenv:py27-flake8] basepython = python2.7 deps = flake8 commands = flake8 . [testenv:py34-flake8] basepython = python3.4 deps = flake8 commands = flake8 . SQLObject-3.1.0/sqlobject/0000755000175000017500000000000012754657361014657 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/cache.py0000644000175000017500000002673512471371300016267 0ustar phdphd00000000000000""" This implements the instance caching in SQLObject. Caching is relatively aggressive. All objects are retained so long as they are in memory, by keeping weak references to objects. We also keep other objects in a cache that doesn't allow them to be garbage collected (unless caching is turned off). """ import threading from weakref import ref class CacheFactory(object): """ CacheFactory caches object creation. Each object should be referenced by a single hashable ID (note tuples of hashable values are also hashable). """ def __init__(self, cullFrequency=100, cullFraction=2, cache=True): """ Every cullFrequency times that an item is retrieved from this cache, the cull method is called. The cull method then expires an arbitrary fraction of the cached objects. The idea is at no time will the cache be entirely emptied, placing a potentially high load at that moment, but everything object will have its time to go eventually. The fraction is given as an integer, and one in that many objects are expired (i.e., the default is 1/2 of objects are expired). By setting cache to False, items won't be cached. However, in all cases a weak reference is kept to created objects, and if the object hasn't been garbage collected it will be returned. """ self.cullFrequency = cullFrequency self.cullCount = 0 self.cullOffset = 0 self.cullFraction = cullFraction self.doCache = cache if self.doCache: self.cache = {} self.expiredCache = {} self.lock = threading.Lock() def tryGet(self, id): """ This returns None, or the object in cache. """ value = self.expiredCache.get(id) if value: # it's actually a weakref: return value() if not self.doCache: return None return self.cache.get(id) def get(self, id): """ This method can cause deadlocks! tryGet is safer This returns the object found in cache, or None. If None, then the cache will remain locked! This is so that the calling function can create the object in a threadsafe manner before releasing the lock. You should use this like (note that ``cache`` is actually a CacheSet object in this example):: obj = cache.get(some_id, my_class) if obj is None: try: obj = create_object(some_id) cache.put(some_id, my_class, obj) finally: cache.finishPut(cls) This method checks both the main cache (which retains references) and the 'expired' cache, which retains only weak references. """ if self.doCache: if self.cullCount > self.cullFrequency: # Two threads could hit the cull in a row, but # that's not so bad. At least by setting cullCount # back to zero right away we avoid this. The cull # method has a lock, so it's threadsafe. self.cullCount = 0 self.cull() else: self.cullCount = self.cullCount + 1 try: return self.cache[id] except KeyError: pass self.lock.acquire() try: val = self.cache[id] except KeyError: pass else: self.lock.release() return val try: val = self.expiredCache[id]() except KeyError: return None else: del self.expiredCache[id] if val is None: return None self.cache[id] = val self.lock.release() return val else: try: val = self.expiredCache[id]() if val is not None: return val except KeyError: pass self.lock.acquire() try: val = self.expiredCache[id]() except KeyError: return None else: if val is None: del self.expiredCache[id] return None self.lock.release() return val def put(self, id, obj): """ Puts an object into the cache. Should only be called after .get(), so that duplicate objects don't end up in the cache. """ if self.doCache: self.cache[id] = obj else: self.expiredCache[id] = ref(obj) def finishPut(self): """ Releases the lock that is retained when .get() is called and returns None. """ self.lock.release() def created(self, id, obj): """ Inserts and object into the cache. Should be used when no one else knows about the object yet, so there cannot be any object already in the cache. After a database INSERT is an example of this situation. """ if self.doCache: if self.cullCount > self.cullFrequency: # Two threads could hit the cull in a row, but # that's not so bad. At least by setting cullCount # back to zero right away we avoid this. The cull # method has a lock, so it's threadsafe. self.cullCount = 0 self.cull() else: self.cullCount = self.cullCount + 1 self.cache[id] = obj else: self.expiredCache[id] = ref(obj) def cull(self): """Runs through the cache and expires objects E.g., if ``cullFraction`` is 3, then every third object is moved to the 'expired' (aka weakref) cache. """ self.lock.acquire() try: # remove dead references from the expired cache keys = list(self.expiredCache.keys()) for key in keys: if self.expiredCache[key]() is None: self.expiredCache.pop(key, None) keys = list(self.cache.keys()) for i in range(self.cullOffset, len(keys), self.cullFraction): id = keys[i] # create a weakref, then remove from the cache obj = ref(self.cache[id]) del self.cache[id] # the object may have been gc'd when removed from the cache # above, no need to place in expiredCache if obj() is not None: self.expiredCache[id] = obj # This offset tries to balance out which objects we # expire, so no object will just hang out in the cache # forever. self.cullOffset = (self.cullOffset + 1) % self.cullFraction finally: self.lock.release() def clear(self): """ Removes everything from the cache. Warning! This can cause duplicate objects in memory. """ if self.doCache: self.cache.clear() self.expiredCache.clear() def expire(self, id): """ Expires a single object. Typically called after a delete. Doesn't even keep a weakref. (@@: bad name?) """ if not self.doCache: return self.lock.acquire() try: if id in self.cache: del self.cache[id] if id in self.expiredCache: del self.expiredCache[id] finally: self.lock.release() def expireAll(self): """ Expires all objects, moving them all into the expired/weakref cache. """ if not self.doCache: return self.lock.acquire() try: for key, value in self.cache.items(): self.expiredCache[key] = ref(value) self.cache = {} finally: self.lock.release() def allIDs(self): """ Returns the IDs of all objects in the cache. """ if self.doCache: all = list(self.cache.keys()) else: all = [] for id, value in self.expiredCache.items(): if value(): all.append(id) return all def getAll(self): """ Return all the objects in the cache. """ if self.doCache: all = list(self.cache.values()) else: all = [] for value in self.expiredCache.values(): if value(): all.append(value()) return all class CacheSet(object): """ A CacheSet is used to collect and maintain a series of caches. In SQLObject, there is one CacheSet per connection, and one Cache in the CacheSet for each class, since IDs are not unique across classes. It contains methods similar to Cache, but that take a ``cls`` argument. """ def __init__(self, *args, **kw): self.caches = {} self.args = args self.kw = kw def get(self, id, cls): try: return self.caches[cls.__name__].get(id) except KeyError: self.caches[cls.__name__] = CacheFactory(*self.args, **self.kw) return self.caches[cls.__name__].get(id) def put(self, id, cls, obj): self.caches[cls.__name__].put(id, obj) def finishPut(self, cls): self.caches[cls.__name__].finishPut() def created(self, id, cls, obj): try: self.caches[cls.__name__].created(id, obj) except KeyError: self.caches[cls.__name__] = CacheFactory(*self.args, **self.kw) self.caches[cls.__name__].created(id, obj) def expire(self, id, cls): try: self.caches[cls.__name__].expire(id) except KeyError: pass def clear(self, cls=None): if cls is None: for cache in self.caches.values(): cache.clear() elif cls.__name__ in self.caches: self.caches[cls.__name__].clear() def tryGet(self, id, cls): return self.tryGetByName(id, cls.__name__) def tryGetByName(self, id, clsname): try: return self.caches[clsname].tryGet(id) except KeyError: return None def allIDs(self, cls): try: self.caches[cls.__name__].allIDs() except KeyError: return [] def allSubCaches(self): return self.caches.values() def allSubCachesByClassNames(self): return self.caches def weakrefAll(self, cls=None): """ Move all objects in the cls (or if not given, then in all classes) to the weakref dictionary, where they can be collected. """ if cls is None: for cache in self.caches.values(): cache.expireAll() elif cls.__name__ in self.caches: self.caches[cls.__name__].expireAll() def getAll(self, cls=None): """ Returns all instances in the cache for the given class or all classes. """ if cls is None: results = [] for cache in self.caches.values(): results.extend(cache.getAll()) return results elif cls.__name__ in self.caches: return self.caches[cls.__name__].getAll() else: return [] SQLObject-3.1.0/sqlobject/mysql/0000755000175000017500000000000012754657361016024 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/mysql/__init__.py0000644000175000017500000000027412464733165020133 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import mysqlconnection return mysqlconnection.MySQLConnection registerConnection(['mysql'], builder) SQLObject-3.1.0/sqlobject/mysql/mysqlconnection.py0000644000175000017500000003445512503207731021616 0ustar phdphd00000000000000from sqlobject import col, dberrors from sqlobject.compat import PY2 from sqlobject.dbconnection import DBAPI class ErrorMessage(str): def __new__(cls, e, append_msg=''): obj = str.__new__(cls, e.args[1] + append_msg) obj.code = int(e.args[0]) obj.module = e.__module__ obj.exception = e.__class__.__name__ return obj mysql_Bin = None class MySQLConnection(DBAPI): supportTransactions = False dbName = 'mysql' schemes = [dbName] def __init__(self, db, user, password='', host='localhost', port=0, **kw): import MySQLdb, MySQLdb.constants.CR, MySQLdb.constants.ER # noqa self.module = MySQLdb self.host = host self.port = port self.db = db self.user = user self.password = password self.kw = {} for key in ("unix_socket", "init_command", "read_default_file", "read_default_group", "conv"): if key in kw: self.kw[key] = kw.pop(key) for key in ("connect_timeout", "compress", "named_pipe", "use_unicode", "client_flag", "local_infile"): if key in kw: self.kw[key] = int(kw.pop(key)) for key in ("ssl_key", "ssl_cert", "ssl_ca", "ssl_capath"): if key in kw: if "ssl" not in self.kw: self.kw["ssl"] = {} self.kw["ssl"][key[4:]] = kw.pop(key) if "charset" in kw: self.dbEncoding = self.kw["charset"] = kw.pop("charset") else: self.dbEncoding = None global mysql_Bin if not PY2 and mysql_Bin is None: mysql_Bin = MySQLdb.Binary MySQLdb.Binary = lambda x: mysql_Bin(x).decode( 'ascii', errors='surrogateescape') if self.module.version_info[:3] < (1, 2, 2): raise ValueError('SQLObject requires MySQLdb 1.2.2 or later') self._server_version = None self._can_use_microseconds = None DBAPI.__init__(self, **kw) @classmethod def _connectionFromParams(cls, user, password, host, port, path, args): return cls(db=path.strip('/'), user=user or '', password=password or '', host=host or 'localhost', port=port or 0, **args) def makeConnection(self): dbEncoding = self.dbEncoding if dbEncoding: from MySQLdb.connections import Connection if not hasattr(Connection, 'set_character_set'): # monkeypatch pre MySQLdb 1.2.1 def character_set_name(self): return dbEncoding + '_' + dbEncoding Connection.character_set_name = character_set_name try: conn = self.module.connect( host=self.host, port=self.port, db=self.db, user=self.user, passwd=self.password, **self.kw) if self.module.version_info[:3] >= (1, 2, 2): # Attempt to reconnect. This setting is persistent. conn.ping(True) except self.module.OperationalError as e: conninfo = ("; used connection string: " "host=%(host)s, port=%(port)s, " "db=%(db)s, user=%(user)s" % self.__dict__) raise dberrors.OperationalError(ErrorMessage(e, conninfo)) if hasattr(conn, 'autocommit'): conn.autocommit(bool(self.autoCommit)) if dbEncoding: if hasattr(conn, 'set_character_set'): # MySQLdb 1.2.1 and later conn.set_character_set(dbEncoding) else: # pre MySQLdb 1.2.1 # works along with monkeypatching code above conn.query("SET NAMES %s" % dbEncoding) return conn def _setAutoCommit(self, conn, auto): if hasattr(conn, 'autocommit'): conn.autocommit(auto) def _executeRetry(self, conn, cursor, query): # When a server connection is lost and a query is attempted, most of # the time the query will raise a SERVER_LOST exception, then at the # second attempt to execute it, the mysql lib will reconnect and # succeed. However is a few cases, the first attempt raises the # SERVER_GONE exception, the second attempt the SERVER_LOST exception # and only the third succeeds. Thus the 3 in the loop count. # If it doesn't reconnect even after 3 attempts, while the database is # up and running, it is because a 5.0.3 (or newer) server is used # which no longer permits autoreconnects by default. In that case a # reconnect flag must be set when making the connection to indicate # that autoreconnecting is desired. In MySQLdb 1.2.2 or newer this is # done by calling ping(True) on the connection. for count in range(3): try: return cursor.execute(query) except self.module.OperationalError as e: if e.args[0] in (self.module.constants.CR.SERVER_GONE_ERROR, self.module.constants.CR.SERVER_LOST): if count == 2: raise dberrors.OperationalError(ErrorMessage(e)) if self.debug: self.printDebug(conn, str(e), 'ERROR') else: raise dberrors.OperationalError(ErrorMessage(e)) except self.module.IntegrityError as e: msg = ErrorMessage(e) if e.args[0] == self.module.constants.ER.DUP_ENTRY: raise dberrors.DuplicateEntryError(msg) else: raise dberrors.IntegrityError(msg) except self.module.InternalError as e: raise dberrors.InternalError(ErrorMessage(e)) except self.module.ProgrammingError as e: raise dberrors.ProgrammingError(ErrorMessage(e)) except self.module.DataError as e: raise dberrors.DataError(ErrorMessage(e)) except self.module.NotSupportedError as e: raise dberrors.NotSupportedError(ErrorMessage(e)) except self.module.DatabaseError as e: raise dberrors.DatabaseError(ErrorMessage(e)) except self.module.InterfaceError as e: raise dberrors.InterfaceError(ErrorMessage(e)) except self.module.Warning as e: raise Warning(ErrorMessage(e)) except self.module.Error as e: raise dberrors.Error(ErrorMessage(e)) def _queryInsertID(self, conn, soInstance, id, names, values): table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName c = conn.cursor() if id is not None: names = [idName] + names values = [id] + values q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') self._executeRetry(conn, c, q) if id is None: try: id = c.lastrowid except AttributeError: id = c.insert_id() if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id @classmethod def _queryAddLimitOffset(cls, query, start, end): if not start: return "%s LIMIT %i" % (query, end) if not end: return "%s LIMIT %i, -1" % (query, start) return "%s LIMIT %i, %i" % (query, start, end - start) def createReferenceConstraint(self, soClass, col): return col.mysqlCreateReferenceConstraint() def createColumn(self, soClass, col): return col.mysqlCreateSQL(self) def createIndexSQL(self, soClass, index): return index.mysqlCreateIndexSQL(soClass) def createIDColumn(self, soClass): if soClass.sqlmeta.idType == str: return '%s TEXT PRIMARY KEY' % soClass.sqlmeta.idName return '%s INT PRIMARY KEY AUTO_INCREMENT' % soClass.sqlmeta.idName def joinSQLType(self, join): return 'INT NOT NULL' def tableExists(self, tableName): try: # Use DESCRIBE instead of SHOW TABLES because SHOW TABLES # assumes there is a default database selected # which is not always True (for an embedded application, e.g.) self.query('DESCRIBE %s' % (tableName)) return True except dberrors.ProgrammingError as e: if e.args[0].code == 1146: # ER_NO_SUCH_TABLE return False raise def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD COLUMN %s' % (tableName, column.mysqlCreateSQL(self))) def delColumn(self, sqlmeta, column): self.query('ALTER TABLE %s DROP COLUMN %s' % (sqlmeta.table, column.dbName)) def columnsFromSchema(self, tableName, soClass): colData = self.queryAll("SHOW COLUMNS FROM %s" % tableName) results = [] for field, t, nullAllowed, key, default, extra in colData: if field == soClass.sqlmeta.idName: continue colClass, kw = self.guessClass(t) if self.kw.get('use_unicode') and colClass is col.StringCol: colClass = col.UnicodeCol if self.dbEncoding: kw['dbEncoding'] = self.dbEncoding kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['dbName'] = field # Since MySQL 5.0, 'NO' is returned in the NULL column # (SQLObject expected '') kw['notNone'] = (nullAllowed.upper() != 'YES' and True or False) if default and t.startswith('int'): kw['default'] = int(default) elif default and t.startswith('float'): kw['default'] = float(default) elif default == 'CURRENT_TIMESTAMP' and t == 'timestamp': kw['default'] = None elif default and colClass is col.BoolCol: kw['default'] = int(default) and True or False else: kw['default'] = default # @@ skip key... # @@ skip extra... results.append(colClass(**kw)) return results def guessClass(self, t): if t.startswith('int'): return col.IntCol, {} elif t.startswith('enum'): values = [] for i in t[5:-1].split(','): # take the enum() off and split values.append(i[1:-1]) # remove the surrounding \' return col.EnumCol, {'enumValues': values} elif t.startswith('double'): return col.FloatCol, {} elif t.startswith('varchar'): colType = col.StringCol if self.kw.get('use_unicode', False): colType = col.UnicodeCol if t.endswith('binary'): return colType, {'length': int(t[8:-8]), 'char_binary': True} else: return colType, {'length': int(t[8:-1])} elif t.startswith('char'): if t.endswith('binary'): return col.StringCol, {'length': int(t[5:-8]), 'varchar': False, 'char_binary': True} else: return col.StringCol, {'length': int(t[5:-1]), 'varchar': False} elif t.startswith('datetime'): return col.DateTimeCol, {} elif t.startswith('date'): return col.DateCol, {} elif t.startswith('time'): return col.TimeCol, {} elif t.startswith('timestamp'): return col.TimestampCol, {} elif t.startswith('bool'): return col.BoolCol, {} elif t.startswith('tinyblob'): return col.BLOBCol, {"length": 2 ** 8 - 1} elif t.startswith('tinytext'): return col.StringCol, {"length": 2 ** 8 - 1, "varchar": True} elif t.startswith('blob'): return col.BLOBCol, {"length": 2 ** 16 - 1} elif t.startswith('text'): return col.StringCol, {"length": 2 ** 16 - 1, "varchar": True} elif t.startswith('mediumblob'): return col.BLOBCol, {"length": 2 ** 24 - 1} elif t.startswith('mediumtext'): return col.StringCol, {"length": 2 ** 24 - 1, "varchar": True} elif t.startswith('longblob'): return col.BLOBCol, {"length": 2 ** 32} elif t.startswith('longtext'): return col.StringCol, {"length": 2 ** 32, "varchar": True} else: return col.Col, {} def listTables(self): return [v[0] for v in self.queryAll("SHOW TABLES")] def listDatabases(self): return [v[0] for v in self.queryAll("SHOW DATABASES")] def _createOrDropDatabase(self, op="CREATE"): self.query('%s DATABASE %s' % (op, self.db)) def createEmptyDatabase(self): self._createOrDropDatabase() def dropDatabase(self): self._createOrDropDatabase(op="DROP") def server_version(self): if self._server_version is not None: return self._server_version try: server_version = self.queryOne("SELECT VERSION()")[0] server_version = server_version.split('-', 1) db_tag = "MySQL" if len(server_version) == 2: if "MariaDB" in server_version[1]: db_tag = "MariaDB" server_version = server_version[0] server_version = tuple(int(v) for v in server_version.split('.')) server_version = (server_version, db_tag) except: server_version = None # unknown self._server_version = server_version return server_version def can_use_microseconds(self): if self._can_use_microseconds is not None: return self._can_use_microseconds server_version = self.server_version() if server_version is None: return None server_version, db_tag = server_version if db_tag == "MariaDB": can_use_microseconds = (server_version >= (5, 3, 0)) else: # MySQL can_use_microseconds = (server_version >= (5, 6, 4)) self._can_use_microseconds = can_use_microseconds return can_use_microseconds SQLObject-3.1.0/sqlobject/declarative.py0000644000175000017500000001650712471371300017503 0ustar phdphd00000000000000""" Declarative objects. Declarative objects have a simple protocol: you can use classes in lieu of instances and they are equivalent, and any keyword arguments you give to the constructor will override those instance variables. (So if a class is received, we'll simply instantiate an instance with no arguments). You can provide a variable __unpackargs__ (a list of strings), and if the constructor is called with non-keyword arguments they will be interpreted as the given keyword arguments. If __unpackargs__ is ('*', name), then all the arguments will be put in a variable by that name. You can define a __classinit__(cls, new_attrs) method, which will be called when the class is created (including subclasses). Note: you can't use super() in __classinit__ because the class isn't bound to a name. As an analog to __classinit__, Declarative adds __instanceinit__ which is called with the same argument (new_attrs). This is like __init__, but after __unpackargs__ and other factors have been taken into account. If __mutableattributes__ is defined as a sequence of strings, these attributes will not be shared between superclasses and their subclasses. E.g., if you have a class variable that contains a list and you append to that list, changes to subclasses will effect superclasses unless you add the attribute here. Also defines classinstancemethod, which acts as either a class method or an instance method depending on where it is called. """ import copy from . import events from sqlobject.compat import with_metaclass import itertools counter = itertools.count() __all__ = ('classinstancemethod', 'DeclarativeMeta', 'Declarative') class classinstancemethod(object): """ Acts like a class method when called from a class, like an instance method when called by an instance. The method should take two arguments, 'self' and 'cls'; one of these will be None depending on how the method was called. """ def __init__(self, func): self.func = func def __get__(self, obj, type=None): return _methodwrapper(self.func, obj=obj, type=type) class _methodwrapper(object): def __init__(self, func, obj, type): self.func = func self.obj = obj self.type = type def __call__(self, *args, **kw): assert 'self' not in kw and 'cls' not in kw, ( "You cannot use 'self' or 'cls' arguments to a " "classinstancemethod") return self.func(*((self.obj, self.type) + args), **kw) def __repr__(self): if self.obj is None: return ('' % (self.type.__name__, self.func.__name__)) else: return ('' % (self.type.__name__, self.func.__name__, self.obj)) class DeclarativeMeta(type): def __new__(meta, class_name, bases, new_attrs): post_funcs = [] early_funcs = [] events.send(events.ClassCreateSignal, bases[0], class_name, bases, new_attrs, post_funcs, early_funcs) cls = type.__new__(meta, class_name, bases, new_attrs) for func in early_funcs: func(cls) if '__classinit__' in new_attrs: if hasattr(cls.__classinit__, '__func__'): cls.__classinit__ = staticmethod(cls.__classinit__.__func__) else: cls.__classinit__ = staticmethod(cls.__classinit__) cls.__classinit__(cls, new_attrs) for func in post_funcs: func(cls) return cls class Declarative(with_metaclass(DeclarativeMeta, object)): __unpackargs__ = () __mutableattributes__ = () __restrict_attributes__ = None def __classinit__(cls, new_attrs): cls.declarative_count = next(counter) for name in cls.__mutableattributes__: if name not in new_attrs: setattr(cls, copy.copy(getattr(cls, name))) def __instanceinit__(self, new_attrs): if self.__restrict_attributes__ is not None: for name in new_attrs: if name not in self.__restrict_attributes__: raise TypeError( '%s() got an unexpected keyword argument %r' % (self.__class__.__name__, name)) for name, value in new_attrs.items(): setattr(self, name, value) if 'declarative_count' not in new_attrs: self.declarative_count = next(counter) def __init__(self, *args, **kw): if self.__unpackargs__ and self.__unpackargs__[0] == '*': assert len(self.__unpackargs__) == 2, \ "When using __unpackargs__ = ('*', varname), " \ "you must only provide a single variable name " \ "(you gave %r)" % self.__unpackargs__ name = self.__unpackargs__[1] if name in kw: raise TypeError( "keyword parameter '%s' was given by position and name" % name) kw[name] = args else: if len(args) > len(self.__unpackargs__): raise TypeError( '%s() takes at most %i arguments (%i given)' % (self.__class__.__name__, len(self.__unpackargs__), len(args))) for name, arg in zip(self.__unpackargs__, args): if name in kw: raise TypeError( "keyword parameter '%s' was given by position and name" % name) kw[name] = arg if '__alsocopy' in kw: for name, value in kw['__alsocopy'].items(): if name not in kw: if name in self.__mutableattributes__: value = copy.copy(value) kw[name] = value del kw['__alsocopy'] self.__instanceinit__(kw) def __call__(self, *args, **kw): kw['__alsocopy'] = self.__dict__ return self.__class__(*args, **kw) @classinstancemethod def singleton(self, cls): if self: return self name = '_%s__singleton' % cls.__name__ if not hasattr(cls, name): setattr(cls, name, cls(declarative_count=cls.declarative_count)) return getattr(cls, name) @classinstancemethod def __repr__(self, cls): if self: name = '%s object' % self.__class__.__name__ v = self.__dict__.copy() else: name = '%s class' % cls.__name__ v = cls.__dict__.copy() if 'declarative_count' in v: name = '%s %i' % (name, v['declarative_count']) del v['declarative_count'] # @@: simplifying repr: # v = {} names = v.keys() args = [] for n in self._repr_vars(names): args.append('%s=%r' % (n, v[n])) if not args: return '<%s>' % name else: return '<%s %s>' % (name, ' '.join(args)) @staticmethod def _repr_vars(dictNames): names = [n for n in dictNames if not n.startswith('_') and n != 'declarative_count'] names.sort() return names def setup_attributes(cls, new_attrs): for name, value in new_attrs.items(): if hasattr(value, '__addtoclass__'): value.__addtoclass__(cls, name) SQLObject-3.1.0/sqlobject/dbconnection.py0000644000175000017500000011371212503207731017663 0ustar phdphd00000000000000import atexit import inspect import sys import os import threading import types try: from urlparse import urlparse, parse_qsl from urllib import unquote, quote, urlencode except ImportError: from urllib.parse import urlparse, parse_qsl, unquote, quote, urlencode import warnings import weakref from .cache import CacheSet from . import classregistry from . import col from .converters import sqlrepr from . import sqlbuilder from .util.threadinglocal import local as threading_local from .compat import PY2, string_type, unicode_type warnings.filterwarnings("ignore", "DB-API extension cursor.lastrowid used") _connections = {} def _closeConnection(ref): conn = ref() if conn is not None: conn.close() class ConsoleWriter: def __init__(self, connection, loglevel): # loglevel: None or empty string for stdout; or 'stderr' self.loglevel = loglevel or "stdout" self.dbEncoding = getattr(connection, "dbEncoding", None) or "ascii" def write(self, text): logfile = getattr(sys, self.loglevel) if PY2 and isinstance(text, unicode_type): try: text = text.encode(self.dbEncoding) except UnicodeEncodeError: text = repr(text)[2:-1] # Remove u'...' from the repr logfile.write(text + '\n') class LogWriter: def __init__(self, connection, logger, loglevel): self.logger = logger self.loglevel = loglevel self.logmethod = getattr(logger, loglevel) def write(self, text): self.logmethod(text) def makeDebugWriter(connection, loggerName, loglevel): if not loggerName: return ConsoleWriter(connection, loglevel) import logging logger = logging.getLogger(loggerName) return LogWriter(connection, logger, loglevel) class Boolean(object): """A bool class that also understands some special string keywords Understands: yes/no, true/false, on/off, 1/0, case ignored. """ _keywords = {'1': True, 'yes': True, 'true': True, 'on': True, '0': False, 'no': False, 'false': False, 'off': False} def __new__(cls, value): try: return Boolean._keywords[value.lower()] except (AttributeError, KeyError): return bool(value) class DBConnection: def __init__(self, name=None, debug=False, debugOutput=False, cache=True, style=None, autoCommit=True, debugThreading=False, registry=None, logger=None, loglevel=None): self.name = name self.debug = Boolean(debug) self.debugOutput = Boolean(debugOutput) self.debugThreading = Boolean(debugThreading) self.debugWriter = makeDebugWriter(self, logger, loglevel) self.doCache = Boolean(cache) self.cache = CacheSet(cache=self.doCache) self.style = style self._connectionNumbers = {} self._connectionCount = 1 self.autoCommit = Boolean(autoCommit) self.registry = registry or None classregistry.registry(self.registry).addCallback(self.soClassAdded) registerConnectionInstance(self) atexit.register(_closeConnection, weakref.ref(self)) def oldUri(self): auth = getattr(self, 'user', '') or '' if auth: if self.password: auth = auth + ':' + self.password auth = auth + '@' else: assert not getattr(self, 'password', None), ( 'URIs cannot express passwords without usernames') uri = '%s://%s' % (self.dbName, auth) if self.host: uri += self.host if self.port: uri += ':%d' % self.port uri += '/' db = self.db if db.startswith('/'): db = db[1:] return uri + db def uri(self): auth = getattr(self, 'user', '') or '' if auth: auth = quote(auth) if self.password: auth = auth + ':' + quote(self.password) auth = auth + '@' else: assert not getattr(self, 'password', None), ( 'URIs cannot express passwords without usernames') uri = '%s://%s' % (self.dbName, auth) if self.host: uri += self.host if self.port: uri += ':%d' % self.port uri += '/' db = self.db if db.startswith('/'): db = db[1:] return uri + quote(db) @classmethod def connectionFromOldURI(cls, uri): return cls._connectionFromParams(*cls._parseOldURI(uri)) @classmethod def connectionFromURI(cls, uri): return cls._connectionFromParams(*cls._parseURI(uri)) @staticmethod def _parseOldURI(uri): schema, rest = uri.split(':', 1) assert rest.startswith('/'), \ "URIs must start with scheme:/ -- " \ "you did not include a / (in %r)" % rest if rest.startswith('/') and not rest.startswith('//'): host = None rest = rest[1:] elif rest.startswith('///'): host = None rest = rest[3:] else: rest = rest[2:] if rest.find('/') == -1: host = rest rest = '' else: host, rest = rest.split('/', 1) if host and host.find('@') != -1: user, host = host.rsplit('@', 1) if user.find(':') != -1: user, password = user.split(':', 1) else: password = None else: user = password = None if host and host.find(':') != -1: _host, port = host.split(':') try: port = int(port) except ValueError: raise ValueError("port must be integer, " "got '%s' instead" % port) if not (1 <= port <= 65535): raise ValueError("port must be integer in the range 1-65535, " "got '%d' instead" % port) host = _host else: port = None path = '/' + rest if os.name == 'nt': if (len(rest) > 1) and (rest[1] == '|'): path = "%s:%s" % (rest[0], rest[2:]) args = {} if path.find('?') != -1: path, arglist = path.split('?', 1) arglist = arglist.split('&') for single in arglist: argname, argvalue = single.split('=', 1) argvalue = unquote(argvalue) args[argname] = argvalue return user, password, host, port, path, args @staticmethod def _parseURI(uri): parsed = urlparse(uri) if sys.version_info[0:2] == (2, 6): # In python 2.6, urlparse only parses the uri completely # for certain schemes, so we force the scheme to # something that will be parsed correctly scheme = parsed.scheme parsed = urlparse(uri.replace(scheme, 'http', 1)) host, path = parsed.hostname, parsed.path user, password, port = None, None, None if parsed.username: user = unquote(parsed.username) if parsed.password: password = unquote(parsed.password) if parsed.port: port = int(parsed.port) path = unquote(path) if (os.name == 'nt') and (len(path) > 2): # Preserve backward compatibility with URIs like /C|/path; # replace '|' by ':' if path[2] == '|': path = "%s:%s" % (path[0:2], path[3:]) # Remove leading slash if (path[0] == '/') and (path[2] == ':'): path = path[1:] query = parsed.query # hash-tag / fragment is ignored args = {} if query: for name, value in parse_qsl(query): args[name] = value return user, password, host, port, path, args def soClassAdded(self, soClass): """ This is called for each new class; we use this opportunity to create an instance method that is bound to the class and this connection. """ name = soClass.__name__ assert not hasattr(self, name), ( "Connection %r already has an attribute with the name " "%r (and you just created the conflicting class %r)" % (self, name, soClass)) setattr(self, name, ConnWrapper(soClass, self)) def expireAll(self): """ Expire all instances of objects for this connection. """ cache_set = self.cache cache_set.weakrefAll() for item in cache_set.getAll(): item.expire() class ConnWrapper(object): """ This represents a SQLObject class that is bound to a specific connection (instances have a connection instance variable, but classes are global, so this is binds the connection variable lazily when a class method is accessed) """ # @@: methods that take connection arguments should be explicitly # marked up instead of the implicit use of a connection argument # and inspect.getargspec() def __init__(self, soClass, connection): self._soClass = soClass self._connection = connection def __call__(self, *args, **kw): kw['connection'] = self._connection return self._soClass(*args, **kw) def __getattr__(self, attr): meth = getattr(self._soClass, attr) if not isinstance(meth, types.MethodType): # We don't need to wrap non-methods return meth try: takes_conn = meth.takes_connection except AttributeError: args, varargs, varkw, defaults = inspect.getargspec(meth) assert not varkw and not varargs, ( "I cannot tell whether I must wrap this method, " "because it takes **kw: %r" % meth) takes_conn = 'connection' in args meth.__func__.takes_connection = takes_conn if not takes_conn: return meth return ConnMethodWrapper(meth, self._connection) class ConnMethodWrapper(object): def __init__(self, method, connection): self._method = method self._connection = connection def __getattr__(self, attr): return getattr(self._method, attr) def __call__(self, *args, **kw): kw['connection'] = self._connection return self._method(*args, **kw) def __repr__(self): return '' % ( self._method, self._connection) class DBAPI(DBConnection): """ Subclass must define a `makeConnection()` method, which returns a newly-created connection object. ``queryInsertID`` must also be defined. """ dbName = None def __init__(self, **kw): self._pool = [] self._poolLock = threading.Lock() DBConnection.__init__(self, **kw) self._binaryType = type(self.module.Binary(b'')) def _runWithConnection(self, meth, *args): conn = self.getConnection() try: val = meth(conn, *args) finally: self.releaseConnection(conn) return val def getConnection(self): self._poolLock.acquire() try: if not self._pool: conn = self.makeConnection() self._connectionNumbers[id(conn)] = self._connectionCount self._connectionCount += 1 else: conn = self._pool.pop() if self.debug: s = 'ACQUIRE' if self._pool is not None: s += ' pool=[%s]' % ', '.join( [str(self._connectionNumbers[id(v)]) for v in self._pool]) self.printDebug(conn, s, 'Pool') return conn finally: self._poolLock.release() def releaseConnection(self, conn, explicit=False): if self.debug: if explicit: s = 'RELEASE (explicit)' else: s = 'RELEASE (implicit, autocommit=%s)' % self.autoCommit if self._pool is None: s += ' no pooling' else: s += ' pool=[%s]' % ', '.join( [str(self._connectionNumbers[id(v)]) for v in self._pool]) self.printDebug(conn, s, 'Pool') if self.supportTransactions and not explicit: if self.autoCommit == 'exception': if self.debug: self.printDebug(conn, 'auto/exception', 'ROLLBACK') conn.rollback() raise Exception('Object used outside of a transaction; ' 'implicit COMMIT or ROLLBACK not allowed') elif self.autoCommit: if self.debug: self.printDebug(conn, 'auto', 'COMMIT') if not getattr(conn, 'autocommit', False): conn.commit() else: if self.debug: self.printDebug(conn, 'auto', 'ROLLBACK') conn.rollback() if self._pool is not None: if conn not in self._pool: # @@: We can get duplicate releasing of connections with # the __del__ in Iteration (unfortunately, not sure why # it happens) self._pool.insert(0, conn) else: conn.close() def printDebug(self, conn, s, name, type='query'): if name == 'Pool' and self.debug != 'Pool': return if type == 'query': sep = ': ' else: sep = '->' s = repr(s) n = self._connectionNumbers[id(conn)] spaces = ' ' * (8 - len(name)) if self.debugThreading: threadName = threading.currentThread().getName() threadName = (':' + threadName + ' ' * (8 - len(threadName))) else: threadName = '' msg = '%(n)2i%(threadName)s/%(name)s%(spaces)s%(sep)s %(s)s' % locals() self.debugWriter.write(msg) def _executeRetry(self, conn, cursor, query): if self.debug: self.printDebug(conn, query, 'QueryR') return cursor.execute(query) def _query(self, conn, s): if self.debug: self.printDebug(conn, s, 'Query') self._executeRetry(conn, conn.cursor(), s) def query(self, s): return self._runWithConnection(self._query, s) def _queryAll(self, conn, s): if self.debug: self.printDebug(conn, s, 'QueryAll') c = conn.cursor() self._executeRetry(conn, c, s) value = c.fetchall() if self.debugOutput: self.printDebug(conn, value, 'QueryAll', 'result') return value def queryAll(self, s): return self._runWithConnection(self._queryAll, s) def _queryAllDescription(self, conn, s): """ Like queryAll, but returns (description, rows), where the description is cursor.description (which gives row types) """ if self.debug: self.printDebug(conn, s, 'QueryAllDesc') c = conn.cursor() self._executeRetry(conn, c, s) value = c.fetchall() if self.debugOutput: self.printDebug(conn, value, 'QueryAll', 'result') return c.description, value def queryAllDescription(self, s): return self._runWithConnection(self._queryAllDescription, s) def _queryOne(self, conn, s): if self.debug: self.printDebug(conn, s, 'QueryOne') c = conn.cursor() self._executeRetry(conn, c, s) value = c.fetchone() if self.debugOutput: self.printDebug(conn, value, 'QueryOne', 'result') return value def queryOne(self, s): return self._runWithConnection(self._queryOne, s) def _insertSQL(self, table, names, values): return ("INSERT INTO %s (%s) VALUES (%s)" % (table, ', '.join(names), ', '.join([self.sqlrepr(v) for v in values]))) def transaction(self): return Transaction(self) def queryInsertID(self, soInstance, id, names, values): return self._runWithConnection(self._queryInsertID, soInstance, id, names, values) def iterSelect(self, select): return select.IterationClass(self, self.getConnection(), select, keepConnection=False) def accumulateSelect(self, select, *expressions): """ Apply an accumulate function(s) (SUM, COUNT, MIN, AVG, MAX, etc...) to the select object. """ q = select.queryForSelect().newItems(expressions).\ unlimited().orderBy(None) q = self.sqlrepr(q) val = self.queryOne(q) if len(expressions) == 1: val = val[0] return val def queryForSelect(self, select): return self.sqlrepr(select.queryForSelect()) def _SO_createJoinTable(self, join): self.query(self._SO_createJoinTableSQL(join)) def _SO_createJoinTableSQL(self, join): return ('CREATE TABLE %s (\n%s %s,\n%s %s\n)' % (join.intermediateTable, join.joinColumn, self.joinSQLType(join), join.otherColumn, self.joinSQLType(join))) def _SO_dropJoinTable(self, join): self.query("DROP TABLE %s" % join.intermediateTable) def _SO_createIndex(self, soClass, index): self.query(self.createIndexSQL(soClass, index)) def createIndexSQL(self, soClass, index): assert 0, 'Implement in subclasses' def createTable(self, soClass): createSql, constraints = self.createTableSQL(soClass) self.query(createSql) return constraints def createReferenceConstraints(self, soClass): refConstraints = [self.createReferenceConstraint(soClass, column) for column in soClass.sqlmeta.columnList if isinstance(column, col.SOForeignKey)] refConstraintDefs = [constraint for constraint in refConstraints if constraint] return refConstraintDefs def createSQL(self, soClass): tableCreateSQLs = getattr(soClass.sqlmeta, 'createSQL', None) if tableCreateSQLs: assert isinstance(tableCreateSQLs, (str, list, dict, tuple)), ( '%s.sqlmeta.createSQL must be a str, list, dict or tuple.' % (soClass.__name__)) if isinstance(tableCreateSQLs, dict): tableCreateSQLs = tableCreateSQLs.get( soClass._connection.dbName, []) if isinstance(tableCreateSQLs, str): tableCreateSQLs = [tableCreateSQLs] if isinstance(tableCreateSQLs, tuple): tableCreateSQLs = list(tableCreateSQLs) assert isinstance(tableCreateSQLs, list), ( 'Unable to create a list from %s.sqlmeta.createSQL' % (soClass.__name__)) return tableCreateSQLs or [] def createTableSQL(self, soClass): constraints = self.createReferenceConstraints(soClass) extraSQL = self.createSQL(soClass) createSql = ('CREATE TABLE %s (\n%s\n)' % (soClass.sqlmeta.table, self.createColumns(soClass))) return createSql, constraints + extraSQL def createColumns(self, soClass): columnDefs = [self.createIDColumn(soClass)] \ + [self.createColumn(soClass, col) for col in soClass.sqlmeta.columnList] return ",\n".join([" %s" % c for c in columnDefs]) def createReferenceConstraint(self, soClass, col): assert 0, "Implement in subclasses" def createColumn(self, soClass, col): assert 0, "Implement in subclasses" def dropTable(self, tableName, cascade=False): self.query("DROP TABLE %s" % tableName) def clearTable(self, tableName): # 3-03 @@: Should this have a WHERE 1 = 1 or similar # clause? In some configurations without the WHERE clause # the query won't go through, but maybe we shouldn't override # that. self.query("DELETE FROM %s" % tableName) def createBinary(self, value): """ Create a binary object wrapper for the given database. """ # Default is Binary() function from the connection driver. return self.module.Binary(value) # The _SO_* series of methods are sorts of "friend" methods # with SQLObject. They grab values from the SQLObject instances # or classes freely, but keep the SQLObject class from accessing # the database directly. This way no SQL is actually created # in the SQLObject class. def _SO_update(self, so, values): self.query("UPDATE %s SET %s WHERE %s = (%s)" % (so.sqlmeta.table, ", ".join(["%s = (%s)" % (dbName, self.sqlrepr(value)) for dbName, value in values]), so.sqlmeta.idName, self.sqlrepr(so.id))) def _SO_selectOne(self, so, columnNames): return self._SO_selectOneAlt(so, columnNames, so.q.id == so.id) def _SO_selectOneAlt(self, so, columnNames, condition): if columnNames: columns = [isinstance(x, string_type) and sqlbuilder.SQLConstant(x) or x for x in columnNames] else: columns = None return self.queryOne(self.sqlrepr(sqlbuilder.Select( columns, staticTables=[so.sqlmeta.table], clause=condition))) def _SO_delete(self, so): self.query("DELETE FROM %s WHERE %s = (%s)" % (so.sqlmeta.table, so.sqlmeta.idName, self.sqlrepr(so.id))) def _SO_selectJoin(self, soClass, column, value): return self.queryAll("SELECT %s FROM %s WHERE %s = (%s)" % (soClass.sqlmeta.idName, soClass.sqlmeta.table, column, self.sqlrepr(value))) def _SO_intermediateJoin(self, table, getColumn, joinColumn, value): return self.queryAll("SELECT %s FROM %s WHERE %s = (%s)" % (getColumn, table, joinColumn, self.sqlrepr(value))) def _SO_intermediateDelete(self, table, firstColumn, firstValue, secondColumn, secondValue): self.query("DELETE FROM %s WHERE %s = (%s) AND %s = (%s)" % (table, firstColumn, self.sqlrepr(firstValue), secondColumn, self.sqlrepr(secondValue))) def _SO_intermediateInsert(self, table, firstColumn, firstValue, secondColumn, secondValue): self.query("INSERT INTO %s (%s, %s) VALUES (%s, %s)" % (table, firstColumn, secondColumn, self.sqlrepr(firstValue), self.sqlrepr(secondValue))) def _SO_columnClause(self, soClass, kw): from . import main ops = {None: "IS"} data = [] if 'id' in kw: data.append((soClass.sqlmeta.idName, kw.pop('id'))) for soColumn in soClass.sqlmeta.columnList: key = soColumn.name if key in kw: val = kw.pop(key) if soColumn.from_python: val = soColumn.from_python( val, sqlbuilder.SQLObjectState(soClass, connection=self)) data.append((soColumn.dbName, val)) elif soColumn.foreignName in kw: obj = kw.pop(soColumn.foreignName) if isinstance(obj, main.SQLObject): data.append((soColumn.dbName, obj.id)) else: data.append((soColumn.dbName, obj)) if kw: # pick the first key from kw to use to raise the error, raise TypeError("got an unexpected keyword argument(s): " "%r" % kw.keys()) if not data: return None return ' AND '.join( ['%s %s %s' % (dbName, ops.get(value, "="), self.sqlrepr(value)) for dbName, value in data]) def sqlrepr(self, v): return sqlrepr(v, self.dbName) def __del__(self): self.close() def close(self): if not hasattr(self, '_pool'): # Probably there was an exception while creating this # instance, so it is incomplete. return if not self._pool: return self._poolLock.acquire() try: if not self._pool: # _pool could be filled in a different thread return conns = self._pool[:] self._pool[:] = [] for conn in conns: try: conn.close() except self.module.Error: pass del conn del conns finally: self._poolLock.release() def createEmptyDatabase(self): """ Create an empty database. """ raise NotImplementedError class Iteration(object): def __init__(self, dbconn, rawconn, select, keepConnection=False): self.dbconn = dbconn self.rawconn = rawconn self.select = select self.keepConnection = keepConnection self.cursor = rawconn.cursor() self.query = self.dbconn.queryForSelect(select) if dbconn.debug: dbconn.printDebug(rawconn, self.query, 'Select') self.dbconn._executeRetry(self.rawconn, self.cursor, self.query) def __iter__(self): return self def __next__(self): return self.next() def next(self): result = self.cursor.fetchone() if result is None: self._cleanup() raise StopIteration if result[0] is None: return None if self.select.ops.get('lazyColumns', 0): obj = self.select.sourceClass.get(result[0], connection=self.dbconn) return obj else: obj = self.select.sourceClass.get(result[0], selectResults=result[1:], connection=self.dbconn) return obj def _cleanup(self): if getattr(self, 'query', None) is None: # already cleaned up return self.query = None if not self.keepConnection: self.dbconn.releaseConnection(self.rawconn) self.dbconn = self.rawconn = self.select = self.cursor = None def __del__(self): self._cleanup() class Transaction(object): def __init__(self, dbConnection): # this is to skip __del__ in case of an exception in this __init__ self._obsolete = True self._dbConnection = dbConnection self._connection = dbConnection.getConnection() self._dbConnection._setAutoCommit(self._connection, 0) self.cache = CacheSet(cache=dbConnection.doCache) self._deletedCache = {} self._obsolete = False def assertActive(self): assert not self._obsolete, \ "This transaction has already gone through ROLLBACK; " \ "begin another transaction" def query(self, s): self.assertActive() return self._dbConnection._query(self._connection, s) def queryAll(self, s): self.assertActive() return self._dbConnection._queryAll(self._connection, s) def queryOne(self, s): self.assertActive() return self._dbConnection._queryOne(self._connection, s) def queryInsertID(self, soInstance, id, names, values): self.assertActive() return self._dbConnection._queryInsertID( self._connection, soInstance, id, names, values) def iterSelect(self, select): self.assertActive() # We can't keep the cursor open with results in a transaction, # because we might want to use the connection while we're # still iterating through the results. # @@: But would it be okay for psycopg, with threadsafety # level 2? return iter(list(select.IterationClass(self, self._connection, select, keepConnection=True))) def _SO_delete(self, inst): cls = inst.__class__.__name__ if cls not in self._deletedCache: self._deletedCache[cls] = [] self._deletedCache[cls].append(inst.id) if PY2: meth = types.MethodType(self._dbConnection._SO_delete.__func__, self, self.__class__) else: meth = types.MethodType(self._dbConnection._SO_delete.__func__, self) return meth(inst) def commit(self, close=False): if self._obsolete: # @@: is it okay to get extraneous commits? return if self._dbConnection.debug: self._dbConnection.printDebug(self._connection, '', 'COMMIT') self._connection.commit() subCaches = [(sub[0], sub[1].allIDs()) for sub in self.cache.allSubCachesByClassNames().items()] subCaches.extend([(x[0], x[1]) for x in self._deletedCache.items()]) for cls, ids in subCaches: for id in list(ids): inst = self._dbConnection.cache.tryGetByName(id, cls) if inst is not None: inst.expire() if close: self._makeObsolete() def rollback(self): if self._obsolete: # @@: is it okay to get extraneous rollbacks? return if self._dbConnection.debug: self._dbConnection.printDebug(self._connection, '', 'ROLLBACK') subCaches = [(sub, sub.allIDs()) for sub in self.cache.allSubCaches()] self._connection.rollback() for subCache, ids in subCaches: for id in list(ids): inst = subCache.tryGet(id) if inst is not None: inst.expire() self._makeObsolete() def __getattr__(self, attr): """ If nothing else works, let the parent connection handle it. Except with this transaction as 'self'. Poor man's acquisition? Bad programming? Okay, maybe. """ self.assertActive() attr = getattr(self._dbConnection, attr) try: func = attr.__func__ except AttributeError: if isinstance(attr, ConnWrapper): return ConnWrapper(attr._soClass, self) else: return attr else: if PY2: meth = types.MethodType(func, self, self.__class__) else: meth = types.MethodType(func, self) return meth def _makeObsolete(self): self._obsolete = True if self._dbConnection.autoCommit: self._dbConnection._setAutoCommit(self._connection, 1) self._dbConnection.releaseConnection(self._connection, explicit=True) self._connection = None self._deletedCache = {} def begin(self): # @@: Should we do this, or should begin() be a no-op when we're # not already obsolete? assert self._obsolete, \ "You cannot begin a new transaction session " \ "without rolling back this one" self._obsolete = False self._connection = self._dbConnection.getConnection() self._dbConnection._setAutoCommit(self._connection, 0) def __del__(self): if self._obsolete: return self.rollback() def close(self): raise TypeError('You cannot just close transaction - ' 'you should either call rollback(), commit() ' 'or commit(close=True) ' 'to close the underlying connection.') class ConnectionHub(object): """ This object serves as a hub for connections, so that you can pass in a ConnectionHub to a SQLObject subclass as though it was a connection, but actually bind a real database connection later. You can also bind connections on a per-thread basis. You must hang onto the original ConnectionHub instance, as you cannot retrieve it again from the class or instance. To use the hub, do something like:: hub = ConnectionHub() class MyClass(SQLObject): _connection = hub hub.threadConnection = connectionFromURI('...') """ def __init__(self): self.threadingLocal = threading_local() def __get__(self, obj, type=None): # I'm a little surprised we have to do this, but apparently # the object's private dictionary of attributes doesn't # override this descriptor. if (obj is not None) and '_connection' in obj.__dict__: return obj.__dict__['_connection'] return self.getConnection() def __set__(self, obj, value): obj.__dict__['_connection'] = value def getConnection(self): try: return self.threadingLocal.connection except AttributeError: try: return self.processConnection except AttributeError: raise AttributeError( "No connection has been defined for this thread " "or process") def doInTransaction(self, func, *args, **kw): """ This routine can be used to run a function in a transaction, rolling the transaction back if any exception is raised from that function, and committing otherwise. Use like:: sqlhub.doInTransaction(process_request, os.environ) This will run ``process_request(os.environ)``. The return value will be preserved. """ # @@: In Python 2.5, something usable with with: should also # be added. try: old_conn = self.threadingLocal.connection old_conn_is_threading = True except AttributeError: old_conn = self.processConnection old_conn_is_threading = False conn = old_conn.transaction() if old_conn_is_threading: self.threadConnection = conn else: self.processConnection = conn try: try: value = func(*args, **kw) except: conn.rollback() raise else: conn.commit(close=True) return value finally: if old_conn_is_threading: self.threadConnection = old_conn else: self.processConnection = old_conn def _set_threadConnection(self, value): self.threadingLocal.connection = value def _get_threadConnection(self): return self.threadingLocal.connection def _del_threadConnection(self): del self.threadingLocal.connection threadConnection = property(_get_threadConnection, _set_threadConnection, _del_threadConnection) class ConnectionURIOpener(object): def __init__(self): self.schemeBuilders = {} self.instanceNames = {} self.cachedURIs = {} def registerConnection(self, schemes, builder): for uriScheme in schemes: assert uriScheme not in self.schemeBuilders \ or self.schemeBuilders[uriScheme] is builder, \ "A driver has already been registered " \ "for the URI scheme %s" % uriScheme self.schemeBuilders[uriScheme] = builder def registerConnectionInstance(self, inst): if inst.name: assert (inst.name not in self.instanceNames or self.instanceNames[inst.name] is cls # noqa ), ("A instance has already been registered " "with the name %s" % inst.name) assert inst.name.find(':') == -1, \ "You cannot include ':' " \ "in your class names (%r)" % cls.name # noqa self.instanceNames[inst.name] = inst def connectionForURI(self, uri, oldUri=False, **args): if args: if '?' not in uri: uri += '?' + urlencode(args) else: uri += '&' + urlencode(args) if uri in self.cachedURIs: return self.cachedURIs[uri] if uri.find(':') != -1: scheme, rest = uri.split(':', 1) connCls = self.dbConnectionForScheme(scheme) if oldUri: conn = connCls.connectionFromOldURI(uri) else: conn = connCls.connectionFromURI(uri) else: # We just have a name, not a URI assert uri in self.instanceNames, \ "No SQLObject driver exists under the name %s" % uri conn = self.instanceNames[uri] # @@: Do we care if we clobber another connection? self.cachedURIs[uri] = conn return conn def dbConnectionForScheme(self, scheme): assert scheme in self.schemeBuilders, ( "No SQLObject driver exists for %s (only %s)" % ( scheme, ', '.join(self.schemeBuilders.keys()))) return self.schemeBuilders[scheme]() TheURIOpener = ConnectionURIOpener() registerConnection = TheURIOpener.registerConnection registerConnectionInstance = TheURIOpener.registerConnectionInstance connectionForURI = TheURIOpener.connectionForURI dbConnectionForScheme = TheURIOpener.dbConnectionForScheme # Register DB URI schemas -- do import for side effects # noqa is a directive for flake8 to ignore seemingly unused imports from . import firebird # noqa from . import maxdb # noqa from . import mssql # noqa from . import mysql # noqa from . import postgres # noqa from . import rdbhost # noqa from . import sqlite # noqa from . import sybase # noqa SQLObject-3.1.0/sqlobject/postgres/0000755000175000017500000000000012754657361016525 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/postgres/__init__.py0000644000175000017500000000032512464733165020631 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import pgconnection return pgconnection.PostgresConnection registerConnection(['postgres', 'postgresql', 'psycopg'], builder) SQLObject-3.1.0/sqlobject/postgres/pgconnection.py0000644000175000017500000004206512477353652021572 0ustar phdphd00000000000000from sqlobject.dbconnection import DBAPI import re from sqlobject import col from sqlobject import dberrors from sqlobject import sqlbuilder from sqlobject.converters import registerConverter class ErrorMessage(str): def __new__(cls, e, append_msg=''): obj = str.__new__(cls, e.args[0] + append_msg) if e.__module__ == 'psycopg2': obj.code = getattr(e, 'pgcode', None) obj.error = getattr(e, 'pgerror', None) else: obj.code = obj.error = None obj.module = e.__module__ obj.exception = e.__class__.__name__ return obj class PostgresConnection(DBAPI): supportTransactions = True dbName = 'postgres' schemes = [dbName, 'postgresql'] def __init__(self, dsn=None, host=None, port=None, db=None, user=None, password=None, **kw): drivers = kw.pop('driver', None) or 'psycopg' for driver in drivers.split(','): driver = driver.strip() if not driver: continue try: if driver == 'psycopg2': import psycopg2 as psycopg elif driver == 'psycopg1': import psycopg elif driver == 'psycopg': try: import psycopg2 as psycopg except ImportError: import psycopg elif driver == 'pygresql': import pgdb self.module = pgdb else: raise ValueError( 'Unknown PostgreSQL driver "%s", ' 'expected psycopg2, psycopg1 or pygresql' % driver) except ImportError: pass else: break else: raise ImportError( 'Cannot find a PostgreSQL driver, tried %s' % drivers) if driver.startswith('psycopg'): self.module = psycopg # Register a converter for psycopg Binary type. registerConverter(type(psycopg.Binary('')), PsycoBinaryConverter) self.user = user self.host = host self.port = port self.db = db self.password = password self.dsn_dict = dsn_dict = {} if host: dsn_dict["host"] = host if port: if driver == 'pygresql': dsn_dict["host"] = "%s:%d" % (host, port) else: if psycopg.__version__.split('.')[0] == '1': dsn_dict["port"] = str(port) else: dsn_dict["port"] = port if db: dsn_dict["database"] = db if user: dsn_dict["user"] = user if password: dsn_dict["password"] = password sslmode = kw.pop("sslmode", None) if sslmode: dsn_dict["sslmode"] = sslmode self.use_dsn = dsn is not None if dsn is None: if driver == 'pygresql': dsn = '' if host: dsn += host dsn += ':' if db: dsn += db dsn += ':' if user: dsn += user dsn += ':' if password: dsn += password else: dsn = [] if db: dsn.append('dbname=%s' % db) if user: dsn.append('user=%s' % user) if password: dsn.append('password=%s' % password) if host: dsn.append('host=%s' % host) if port: dsn.append('port=%d' % port) if sslmode: dsn.append('sslmode=%s' % sslmode) dsn = ' '.join(dsn) self.driver = driver self.dsn = dsn self.unicodeCols = kw.pop('unicodeCols', False) self.schema = kw.pop('schema', None) self.dbEncoding = kw.pop("charset", None) DBAPI.__init__(self, **kw) @classmethod def _connectionFromParams(cls, user, password, host, port, path, args): path = path.strip('/') if (host is None) and path.count('/'): # Non-default unix socket path_parts = path.split('/') host = '/' + '/'.join(path_parts[:-1]) path = path_parts[-1] return cls(host=host, port=port, db=path, user=user, password=password, **args) def _setAutoCommit(self, conn, auto): # psycopg2 does not have an autocommit method. if hasattr(conn, 'autocommit'): try: conn.autocommit(auto) except TypeError: conn.autocommit = auto def makeConnection(self): try: if self.use_dsn: conn = self.module.connect(self.dsn) else: conn = self.module.connect(**self.dsn_dict) except self.module.OperationalError as e: raise dberrors.OperationalError( ErrorMessage(e, "used connection string %r" % self.dsn)) # For printDebug in _executeRetry self._connectionNumbers[id(conn)] = self._connectionCount if self.autoCommit: self._setAutoCommit(conn, 1) c = conn.cursor() if self.schema: self._executeRetry(conn, c, "SET search_path TO " + self.schema) dbEncoding = self.dbEncoding if dbEncoding: self._executeRetry(conn, c, "SET client_encoding TO '%s'" % dbEncoding) return conn def _executeRetry(self, conn, cursor, query): if self.debug: self.printDebug(conn, query, 'QueryR') try: return cursor.execute(query) except self.module.OperationalError as e: raise dberrors.OperationalError(ErrorMessage(e)) except self.module.IntegrityError as e: msg = ErrorMessage(e) if e.pgcode == '23505': raise dberrors.DuplicateEntryError(msg) else: raise dberrors.IntegrityError(msg) except self.module.InternalError as e: raise dberrors.InternalError(ErrorMessage(e)) except self.module.ProgrammingError as e: raise dberrors.ProgrammingError(ErrorMessage(e)) except self.module.DataError as e: raise dberrors.DataError(ErrorMessage(e)) except self.module.NotSupportedError as e: raise dberrors.NotSupportedError(ErrorMessage(e)) except self.module.DatabaseError as e: raise dberrors.DatabaseError(ErrorMessage(e)) except self.module.InterfaceError as e: raise dberrors.InterfaceError(ErrorMessage(e)) except self.module.Warning as e: raise Warning(ErrorMessage(e)) except self.module.Error as e: raise dberrors.Error(ErrorMessage(e)) def _queryInsertID(self, conn, soInstance, id, names, values): table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName c = conn.cursor() if id is not None: names = [idName] + names values = [id] + values if names and values: q = self._insertSQL(table, names, values) else: q = "INSERT INTO %s DEFAULT VALUES" % table if id is None: q += " RETURNING " + idName if self.debug: self.printDebug(conn, q, 'QueryIns') self._executeRetry(conn, c, q) if id is None: id = c.fetchone()[0] if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id @classmethod def _queryAddLimitOffset(cls, query, start, end): if not start: return "%s LIMIT %i" % (query, end) if not end: return "%s OFFSET %i" % (query, start) return "%s LIMIT %i OFFSET %i" % (query, end - start, start) def createColumn(self, soClass, col): return col.postgresCreateSQL() def createReferenceConstraint(self, soClass, col): return col.postgresCreateReferenceConstraint() def createIndexSQL(self, soClass, index): return index.postgresCreateIndexSQL(soClass) def createIDColumn(self, soClass): key_type = {int: "SERIAL", str: "TEXT"}[soClass.sqlmeta.idType] return '%s %s PRIMARY KEY' % (soClass.sqlmeta.idName, key_type) def dropTable(self, tableName, cascade=False): self.query("DROP TABLE %s %s" % (tableName, cascade and 'CASCADE' or '')) def joinSQLType(self, join): return 'INT NOT NULL' def tableExists(self, tableName): result = self.queryOne( "SELECT COUNT(relname) FROM pg_class WHERE relname = %s" % self.sqlrepr(tableName)) return result[0] def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD COLUMN %s' % (tableName, column.postgresCreateSQL())) def delColumn(self, sqlmeta, column): self.query('ALTER TABLE %s DROP COLUMN %s' % (sqlmeta.table, column.dbName)) def columnsFromSchema(self, tableName, soClass): keyQuery = """ SELECT pg_catalog.pg_get_constraintdef(oid) as condef FROM pg_catalog.pg_constraint r WHERE r.conrelid = %s::regclass AND r.contype = 'f'""" colQuery = """ SELECT a.attname, pg_catalog.format_type(a.atttypid, a.atttypmod), a.attnotnull, (SELECT substring(d.adsrc for 128) FROM pg_catalog.pg_attrdef d WHERE d.adrelid=a.attrelid AND d.adnum = a.attnum) FROM pg_catalog.pg_attribute a WHERE a.attrelid =%s::regclass AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum""" primaryKeyQuery = """ SELECT pg_index.indisprimary, pg_catalog.pg_get_indexdef(pg_index.indexrelid) FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index AS pg_index WHERE c.relname = %s AND c.oid = pg_index.indrelid AND pg_index.indexrelid = c2.oid AND pg_index.indisprimary """ otherKeyQuery = """ SELECT pg_index.indisprimary, pg_catalog.pg_get_indexdef(pg_index.indexrelid) FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index AS pg_index WHERE c.relname = %s AND c.oid = pg_index.indrelid AND pg_index.indexrelid = c2.oid AND NOT pg_index.indisprimary """ keyData = self.queryAll(keyQuery % self.sqlrepr(tableName)) keyRE = re.compile(r"\((.+)\) REFERENCES (.+)\(") keymap = {} for (condef,) in keyData: match = keyRE.search(condef) if match: field, reftable = match.groups() keymap[field] = reftable.capitalize() primaryData = self.queryAll(primaryKeyQuery % self.sqlrepr(tableName)) primaryRE = re.compile(r'CREATE .*? USING .* \((.+?)\)') primaryKey = None for isPrimary, indexDef in primaryData: match = primaryRE.search(indexDef) assert match, "Unparseable contraint definition: %r" % indexDef assert primaryKey is None, \ "Already found primary key (%r), " \ "then found: %r" % (primaryKey, indexDef) primaryKey = match.group(1) if primaryKey is None: # VIEWs don't have PRIMARY KEYs - accept help from user primaryKey = soClass.sqlmeta.idName assert primaryKey, "No primary key found in table %r" % tableName if primaryKey.startswith('"'): assert primaryKey.endswith('"') primaryKey = primaryKey[1:-1] otherData = self.queryAll(otherKeyQuery % self.sqlrepr(tableName)) otherRE = primaryRE otherKeys = [] for isPrimary, indexDef in otherData: match = otherRE.search(indexDef) assert match, "Unparseable constraint definition: %r" % indexDef otherKey = match.group(1) if otherKey.startswith('"'): assert otherKey.endswith('"') otherKey = otherKey[1:-1] otherKeys.append(otherKey) colData = self.queryAll(colQuery % self.sqlrepr(tableName)) results = [] if self.unicodeCols: client_encoding = self.queryOne("SHOW client_encoding")[0] for field, t, notnull, defaultstr in colData: if field == primaryKey: continue if field in keymap: colClass = col.ForeignKey kw = {'foreignKey': soClass.sqlmeta.style. dbTableToPythonClass(keymap[field])} name = soClass.sqlmeta.style.dbColumnToPythonAttr(field) if name.endswith('ID'): name = name[:-2] kw['name'] = name else: colClass, kw = self.guessClass(t) if self.unicodeCols and colClass is col.StringCol: colClass = col.UnicodeCol kw['dbEncoding'] = client_encoding kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['dbName'] = field kw['notNone'] = notnull if defaultstr is not None: kw['default'] = self.defaultFromSchema(colClass, defaultstr) elif not notnull: kw['default'] = None if field in otherKeys: kw['alternateID'] = True results.append(colClass(**kw)) return results def guessClass(self, t): if t.count('point'): # poINT before INT return col.StringCol, {} elif t.count('int'): return col.IntCol, {} elif t.count('varying') or t.count('varchar'): if '(' in t: return col.StringCol, {'length': int(t[t.index('(') + 1:-1])} else: # varchar without length in Postgres means any length return col.StringCol, {} elif t.startswith('character('): return col.StringCol, {'length': int(t[t.index('(') + 1:-1]), 'varchar': False} elif t.count('float') or t.count('real') or t.count('double'): return col.FloatCol, {} elif t == 'text': return col.StringCol, {} elif t.startswith('timestamp'): return col.DateTimeCol, {} elif t.startswith('datetime'): return col.DateTimeCol, {} elif t.startswith('date'): return col.DateCol, {} elif t.startswith('bool'): return col.BoolCol, {} elif t.startswith('bytea'): return col.BLOBCol, {} else: return col.Col, {} def defaultFromSchema(self, colClass, defaultstr): """ If the default can be converted to a python constant, convert it. Otherwise return is as a sqlbuilder constant. """ if colClass == col.BoolCol: if defaultstr == 'false': return False elif defaultstr == 'true': return True return getattr(sqlbuilder.const, defaultstr) def _createOrDropDatabase(self, op="CREATE"): # We have to connect to *some* database, so we'll connect to # template1, which is a common open database. # @@: This doesn't use self.use_dsn or self.dsn_dict if self.driver == 'pygresql': dsn = '%s:template1:%s:%s' % ( self.host or '', self.user or '', self.password or '') else: dsn = 'dbname=template1' if self.user: dsn += ' user=%s' % self.user if self.password: dsn += ' password=%s' % self.password if self.host: dsn += ' host=%s' % self.host conn = self.module.connect(dsn) cur = conn.cursor() # We must close the transaction with a commit so that # the CREATE DATABASE can work (which can't be in a transaction): try: self._executeRetry(conn, cur, 'COMMIT') self._executeRetry(conn, cur, '%s DATABASE %s' % (op, self.db)) finally: cur.close() conn.close() def listTables(self): return [v[0] for v in self.queryAll( """SELECT c.relname FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid)""")] def listDatabases(self): return [v[0] for v in self.queryAll("SELECT datname FROM pg_database")] def createEmptyDatabase(self): self._createOrDropDatabase() def dropDatabase(self): self._createOrDropDatabase(op="DROP") # Converter for psycopg Binary type. def PsycoBinaryConverter(value, db): assert db == 'postgres' return str(value) SQLObject-3.1.0/sqlobject/converters.py0000644000175000017500000001445212540345350017412 0ustar phdphd00000000000000from array import array import datetime from decimal import Decimal import time import sys from .compat import PY2, buffer_type if PY2: from types import ClassType, InstanceType, NoneType else: # Use suitable aliases for now ClassType = type NoneType = type(None) # This is may not be what we want in all cases, but will do for now InstanceType = object try: from mx.DateTime import DateTimeType, DateTimeDeltaType except ImportError: try: from DateTime import DateTimeType, DateTimeDeltaType except ImportError: DateTimeType = None DateTimeDeltaType = None try: import Sybase NumericType = Sybase.NumericType except ImportError: NumericType = None ######################################## # Quoting ######################################## sqlStringReplace = [ ("'", "''"), ('\\', '\\\\'), ('\000', '\\0'), ('\b', '\\b'), ('\n', '\\n'), ('\r', '\\r'), ('\t', '\\t'), ] class ConverterRegistry: def __init__(self): self.basic = {} self.klass = {} def registerConverter(self, typ, func): if type(typ) is ClassType: self.klass[typ] = func else: self.basic[typ] = func if PY2: def lookupConverter(self, value, default=None): if type(value) is InstanceType: # lookup on klasses dict return self.klass.get(value.__class__, default) return self.basic.get(type(value), default) else: def lookupConverter(self, value, default=None): # python 3 doesn't have classic classes, so everything's # in self.klass due to comparison order in registerConvertor return self.klass.get(value.__class__, default) converters = ConverterRegistry() registerConverter = converters.registerConverter lookupConverter = converters.lookupConverter def StringLikeConverter(value, db): if isinstance(value, array): try: value = value.tounicode() except ValueError: value = value.tostring() elif isinstance(value, buffer_type): value = str(value) if db in ('mysql', 'postgres', 'rdbhost'): for orig, repl in sqlStringReplace: value = value.replace(orig, repl) elif db in ('sqlite', 'firebird', 'sybase', 'maxdb', 'mssql'): value = value.replace("'", "''") else: assert 0, "Database %s unknown" % db if db in ('postgres', 'rdbhost') and ('\\' in value): return "E'%s'" % value return "'%s'" % value registerConverter(str, StringLikeConverter) if PY2: # noqa for flake8 & python3 registerConverter(unicode, StringLikeConverter) # noqa registerConverter(array, StringLikeConverter) if PY2: registerConverter(buffer_type, StringLikeConverter) else: registerConverter(memoryview, StringLikeConverter) def IntConverter(value, db): return repr(int(value)) registerConverter(int, IntConverter) def LongConverter(value, db): return str(value) if sys.version_info[0] < 3: # noqa for flake8 & python3 registerConverter(long, LongConverter) # noqa if NumericType: registerConverter(NumericType, IntConverter) def BoolConverter(value, db): if db in ('postgres', 'rdbhost'): if value: return "'t'" else: return "'f'" else: if value: return '1' else: return '0' registerConverter(bool, BoolConverter) def FloatConverter(value, db): return repr(value) registerConverter(float, FloatConverter) if DateTimeType: def mxDateTimeConverter(value, db): return "'%s'" % value.strftime("%Y-%m-%d %H:%M:%S") registerConverter(DateTimeType, mxDateTimeConverter) def mxTimeConverter(value, db): return "'%s'" % value.strftime("%H:%M:%S") registerConverter(DateTimeDeltaType, mxTimeConverter) def NoneConverter(value, db): return "NULL" registerConverter(NoneType, NoneConverter) def SequenceConverter(value, db): return "(%s)" % ", ".join([sqlrepr(v, db) for v in value]) registerConverter(tuple, SequenceConverter) registerConverter(list, SequenceConverter) registerConverter(dict, SequenceConverter) registerConverter(set, SequenceConverter) registerConverter(frozenset, SequenceConverter) if hasattr(time, 'struct_time'): def StructTimeConverter(value, db): return time.strftime("'%Y-%m-%d %H:%M:%S'", value) registerConverter(time.struct_time, StructTimeConverter) def DateTimeConverter(value, db): return "'%04d-%02d-%02d %02d:%02d:%02d'" % ( value.year, value.month, value.day, value.hour, value.minute, value.second) def DateTimeConverterMS(value, db): return "'%04d-%02d-%02d %02d:%02d:%02d.%06d'" % ( value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond) registerConverter(datetime.datetime, DateTimeConverterMS) def DateConverter(value, db): return "'%04d-%02d-%02d'" % (value.year, value.month, value.day) registerConverter(datetime.date, DateConverter) def TimeConverter(value, db): return "'%02d:%02d:%02d'" % (value.hour, value.minute, value.second) def TimeConverterMS(value, db): return "'%02d:%02d:%02d.%06d'" % (value.hour, value.minute, value.second, value.microsecond) registerConverter(datetime.time, TimeConverterMS) def DecimalConverter(value, db): return value.to_eng_string() registerConverter(Decimal, DecimalConverter) def TimedeltaConverter(value, db): return """INTERVAL '%d days %d seconds'""" % \ (value.days, value.seconds) registerConverter(datetime.timedelta, TimedeltaConverter) def sqlrepr(obj, db=None): try: reprFunc = obj.__sqlrepr__ except AttributeError: converter = lookupConverter(obj) if converter is None: raise ValueError("Unknown SQL builtin type: %s for %s" % (type(obj), repr(obj))) return converter(obj, db) else: return reprFunc(db) def quote_str(s, db): if db in ('postgres', 'rdbhost') and ('\\' in s): return "E'%s'" % s return "'%s'" % s def unquote_str(s): if s[:2].upper().startswith("E'") and s.endswith("'"): return s[2:-1] elif s.startswith("'") and s.endswith("'"): return s[1:-1] else: return s SQLObject-3.1.0/sqlobject/manager/0000755000175000017500000000000012754657361016271 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/manager/__init__.py0000644000175000017500000000000210223355362020353 0ustar phdphd00000000000000# SQLObject-3.1.0/sqlobject/manager/command.py0000755000175000017500000014145412503207731020255 0ustar phdphd00000000000000#!/usr/bin/env python from __future__ import print_function import fnmatch import optparse import os import re import sys import textwrap import time import warnings try: from paste.deploy import appconfig except ImportError: appconfig = None import sqlobject from sqlobject import col from sqlobject.classregistry import findClass from sqlobject.declarative import DeclarativeMeta from sqlobject.util import moduleloader from sqlobject.compat import PY2, with_metaclass, string_type # It's not very unsafe to use tempnam like we are doing: warnings.filterwarnings( 'ignore', 'tempnam is a potential security risk.*', RuntimeWarning, '.*command', 28) if PY2: # noqa for flake8 and python 3 input = raw_input # noqa def nowarning_tempnam(*args, **kw): return os.tempnam(*args, **kw) class SQLObjectVersionTable(sqlobject.SQLObject): """ This table is used to store information about the database and its version (used with record and update commands). """ class sqlmeta: table = 'sqlobject_db_version' version = col.StringCol() updated = col.DateTimeCol(default=col.DateTimeCol.now) def db_differences(soClass, conn): """ Returns the differences between a class and the table in a connection. Returns [] if no differences are found. This function does the best it can; it can miss many differences. """ # @@: Repeats a lot from CommandStatus.command, but it's hard # to actually factor out the display logic. Or I'm too lazy # to do so. diffs = [] if not conn.tableExists(soClass.sqlmeta.table): if soClass.sqlmeta.columns: diffs.append('Does not exist in database') else: try: columns = conn.columnsFromSchema(soClass.sqlmeta.table, soClass) except AttributeError: # Database does not support reading columns pass else: existing = {} for _col in columns: _col = _col.withClass(soClass) existing[_col.dbName] = _col missing = {} for _col in soClass.sqlmeta.columnList: if _col.dbName in existing: del existing[_col.dbName] else: missing[_col.dbName] = _col for _col in existing.values(): diffs.append('Database has extra column: %s' % _col.dbName) for _col in missing.values(): diffs.append('Database missing column: %s' % _col.dbName) return diffs class CommandRunner(object): def __init__(self): self.commands = {} self.command_aliases = {} def run(self, argv): invoked_as = argv[0] args = argv[1:] for i in range(len(args)): if not args[i].startswith('-'): # this must be a command command = args[i].lower() del args[i] break else: # no command found self.invalid('No COMMAND given (try "%s help")' % os.path.basename(invoked_as)) real_command = self.command_aliases.get(command, command) if real_command not in self.commands.keys(): self.invalid('COMMAND %s unknown' % command) runner = self.commands[real_command]( invoked_as, command, args, self) runner.run() def register(self, command): name = command.name self.commands[name] = command for alias in command.aliases: self.command_aliases[alias] = name def invalid(self, msg, code=2): print(msg) sys.exit(code) the_runner = CommandRunner() register = the_runner.register def standard_parser(connection=True, simulate=True, interactive=False, find_modules=True): parser = optparse.OptionParser() parser.add_option('-v', '--verbose', help='Be verbose (multiple times for more verbosity)', action='count', dest='verbose', default=0) if simulate: parser.add_option('-n', '--simulate', help="Don't actually do anything (implies -v)", action='store_true', dest='simulate') if connection: parser.add_option('-c', '--connection', help="The database connection URI", metavar='URI', dest='connection_uri') parser.add_option('-f', '--config-file', help="The Paste config file " "that contains the database URI (in the database key)", metavar="FILE", dest="config_file") if find_modules: parser.add_option('-m', '--module', help="Module in which to find SQLObject classes", action='append', metavar='MODULE', dest='modules', default=[]) parser.add_option('-p', '--package', help="Package to search for SQLObject classes", action="append", metavar="PACKAGE", dest="packages", default=[]) parser.add_option('--class', help="Select only named classes (wildcards allowed)", action="append", metavar="NAME", dest="class_matchers", default=[]) if interactive: parser.add_option('-i', '--interactive', help="Ask before doing anything " "(use twice to be more careful)", action="count", dest="interactive", default=0) parser.add_option('--egg', help="Select modules from the given Egg, " "using sqlobject.txt", action="append", metavar="EGG_SPEC", dest="eggs", default=[]) return parser class Command(with_metaclass(DeclarativeMeta, object)): min_args = 0 min_args_error = 'You must provide at least %(min_args)s arguments' max_args = 0 max_args_error = 'You must provide no more than %(max_args)s arguments' aliases = () required_args = [] description = None help = '' def orderClassesByDependencyLevel(self, classes): """ Return classes ordered by their depth in the class dependency tree (this is *not* the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations. """ # @@: written as a self-contained function for now, to prevent # having to modify any core SQLObject component and namespace # contamination. # yemartin - 2006-08-08 class SQLObjectCircularReferenceError(Exception): pass def findReverseDependencies(cls): """ Return a list of classes that cls depends on. Note that "depends on" here mean "has a foreign key pointing to". """ depended = [] for _col in cls.sqlmeta.columnList: if _col.foreignKey: other = findClass(_col.foreignKey, _col.soClass.sqlmeta.registry) if (other is not cls) and (other not in depended): depended.append(other) return depended # Cache to save already calculated dependency levels. dependency_levels = {} def calculateDependencyLevel(cls, dependency_stack=[]): """ Recursively calculate the dependency level of cls, while using the dependency_stack to detect any circular reference. """ # Return value from the cache if already calculated if cls in dependency_levels: return dependency_levels[cls] # Check for circular references if cls in dependency_stack: dependency_stack.append(cls) raise SQLObjectCircularReferenceError( "Found a circular reference: %s " % (' --> '.join([x.__name__ for x in dependency_stack]))) dependency_stack.append(cls) # Recursively inspect dependent classes. depended = findReverseDependencies(cls) if depended: level = max([calculateDependencyLevel(x, dependency_stack) for x in depended]) + 1 else: level = 0 dependency_levels[cls] = level return level # Now simply calculate and sort by dependency levels: try: sorter = [] for cls in classes: level = calculateDependencyLevel(cls) sorter.append((level, cls)) sorter.sort(key=lambda x: x[0]) ordered_classes = [cls for _, cls in sorter] except SQLObjectCircularReferenceError as msg: # Failsafe: return the classes as-is if a circular reference # prevented the dependency levels to be calculated. print("Warning: a circular reference was detected in the " "model. Unable to sort the classes by dependency: they " "will be treated in alphabetic order. This may or may " "not work depending on your database backend. " "The error was:\n%s" % msg) return classes return ordered_classes def __classinit__(cls, new_args): if cls.__bases__ == (object,): # This abstract base class return register(cls) def __init__(self, invoked_as, command_name, args, runner): self.invoked_as = invoked_as self.command_name = command_name self.raw_args = args self.runner = runner def run(self): self.parser.usage = "%%prog [options]\n%s" % self.summary if self.help: help = textwrap.fill( self.help, int(os.environ.get('COLUMNS', 80)) - 4) self.parser.usage += '\n' + help self.parser.prog = '%s %s' % ( os.path.basename(self.invoked_as), self.command_name) if self.description: self.parser.description = self.description self.options, self.args = self.parser.parse_args(self.raw_args) if (getattr(self.options, 'simulate', False) and not self.options.verbose): self.options.verbose = 1 if self.min_args is not None and len(self.args) < self.min_args: self.runner.invalid( self.min_args_error % {'min_args': self.min_args, 'actual_args': len(self.args)}) if self.max_args is not None and len(self.args) > self.max_args: self.runner.invalid( self.max_args_error % {'max_args': self.max_args, 'actual_args': len(self.args)}) for var_name, option_name in self.required_args: if not getattr(self.options, var_name, None): self.runner.invalid( 'You must provide the option %s' % option_name) conf = self.config() if conf and conf.get('sys_path'): update_sys_path(conf['sys_path'], self.options.verbose) if conf and conf.get('database'): conn = sqlobject.connectionForURI(conf['database']) sqlobject.sqlhub.processConnection = conn for egg_spec in getattr(self.options, 'eggs', []): self.load_options_from_egg(egg_spec) self.command() def classes(self, require_connection=True, require_some=False): all = [] for module_name in self.options.modules: all.extend(self.classes_from_module( moduleloader.load_module(module_name))) for package_name in self.options.packages: all.extend(self.classes_from_package(package_name)) for egg_spec in self.options.eggs: all.extend(self.classes_from_egg(egg_spec)) if self.options.class_matchers: filtered = [] for soClass in all: name = soClass.__name__ for matcher in self.options.class_matchers: if fnmatch.fnmatch(name, matcher): filtered.append(soClass) break all = filtered conn = self.connection() if conn: for soClass in all: soClass._connection = conn else: missing = [] for soClass in all: try: if not soClass._connection: missing.append(soClass) except AttributeError: missing.append(soClass) if missing and require_connection: self.runner.invalid( 'These classes do not have connections set:\n * %s\n' 'You must indicate --connection=URI' % '\n * '.join([soClass.__name__ for soClass in missing])) if require_some and not all: print('No classes found!') if self.options.modules: print('Looked in modules: %s' % ', '.join(self.options.modules)) else: print('No modules specified') if self.options.packages: print('Looked in packages: %s' % ', '.join(self.options.packages)) else: print('No packages specified') if self.options.class_matchers: print('Matching class pattern: %s' % self.options.class_matches) if self.options.eggs: print('Looked in eggs: %s' % ', '.join(self.options.eggs)) else: print('No eggs specified') sys.exit(1) return self.orderClassesByDependencyLevel(all) def classes_from_module(self, module): all = [] if hasattr(module, 'soClasses'): for name_or_class in module.soClasses: if isinstance(name_or_class, str): name_or_class = getattr(module, name_or_class) all.append(name_or_class) else: for name in dir(module): value = getattr(module, name) if (isinstance(value, type) and issubclass(value, sqlobject.SQLObject) and value.__module__ == module.__name__): all.append(value) return all def connection(self): config = self.config() if config is not None: assert config.get('database'), ( "No database variable found in config file %s" % self.options.config_file) return sqlobject.connectionForURI(config['database']) elif getattr(self.options, 'connection_uri', None): return sqlobject.connectionForURI(self.options.connection_uri) else: return None def config(self): if not getattr(self.options, 'config_file', None): return None config_file = self.options.config_file if appconfig: if (not config_file.startswith('egg:') and not config_file.startswith('config:')): config_file = 'config:' + config_file return appconfig(config_file, relative_to=os.getcwd()) else: return self.ini_config(config_file) def ini_config(self, conf_fn): conf_section = 'main' if '#' in conf_fn: conf_fn, conf_section = conf_fn.split('#', 1) try: from ConfigParser import ConfigParser except ImportError: from configparser import ConfigParser p = ConfigParser() # Case-sensitive: p.optionxform = str if not os.path.exists(conf_fn): # Stupid RawConfigParser doesn't give an error for # non-existant files: raise OSError( "Config file %s does not exist" % self.options.config_file) p.read([conf_fn]) p._defaults.setdefault( 'here', os.path.dirname(os.path.abspath(conf_fn))) possible_sections = [] for section in p.sections(): name = section.strip().lower() if (conf_section == name or (conf_section == name.split(':')[-1] and name.split(':')[0] in ('app', 'application'))): possible_sections.append(section) if not possible_sections: raise OSError( "Config file %s does not have a section [%s] or [*:%s]" % (conf_fn, conf_section, conf_section)) if len(possible_sections) > 1: raise OSError( "Config file %s has multiple sections matching %s: %s" % (conf_fn, conf_section, ', '.join(possible_sections))) config = {} for op in p.options(possible_sections[0]): config[op] = p.get(possible_sections[0], op) return config def classes_from_package(self, package_name): all = [] package = moduleloader.load_module(package_name) package_dir = os.path.dirname(package.__file__) def find_classes_in_file(arg, dir_name, filenames): if dir_name.startswith('.svn'): return filenames = filter( lambda fname: fname.endswith('.py') and fname != '__init__.py', filenames) for fname in filenames: module_name = os.path.join(dir_name, fname) module_name = module_name[module_name.find(package_name):] module_name = module_name.replace(os.path.sep, '.')[:-3] try: module = moduleloader.load_module(module_name) except ImportError as err: if self.options.verbose: print('Could not import module "%s". ' 'Error was : "%s"' % (module_name, err)) continue except Exception as exc: if self.options.verbose: print('Unknown exception while processing module ' '"%s" : "%s"' % (module_name, exc)) continue classes = self.classes_from_module(module) all.extend(classes) for dirpath, dirnames, filenames in os.walk(package_dir): find_classes_in_file(None, dirpath, dirnames + filenames) return all def classes_from_egg(self, egg_spec): modules = [] dist, conf = self.config_from_egg(egg_spec, warn_no_sqlobject=True) for mod in conf.get('db_module', '').split(','): mod = mod.strip() if not mod: continue if self.options.verbose: print('Looking in module %s' % mod) modules.extend(self.classes_from_module( moduleloader.load_module(mod))) return modules def load_options_from_egg(self, egg_spec): dist, conf = self.config_from_egg(egg_spec) if (hasattr(self.options, 'output_dir') and not self.options.output_dir and conf.get('history_dir')): dir = conf['history_dir'] dir = dir.replace('$base', dist.location) self.options.output_dir = dir def config_from_egg(self, egg_spec, warn_no_sqlobject=True): import pkg_resources dist = pkg_resources.get_distribution(egg_spec) if not dist.has_metadata('sqlobject.txt'): if warn_no_sqlobject: print('No sqlobject.txt in %s egg info' % egg_spec) return None, {} result = {} for line in dist.get_metadata_lines('sqlobject.txt'): line = line.strip() if not line or line.startswith('#'): continue name, value = line.split('=', 1) name = name.strip().lower() if name in result: print('Warning: %s appears more than once ' 'in sqlobject.txt' % name) result[name.strip().lower()] = value.strip() return dist, result def command(self): raise NotImplementedError def _get_prog_name(self): return os.path.basename(self.invoked_as) prog_name = property(_get_prog_name) def ask(self, prompt, safe=False, default=True): if self.options.interactive >= 2: default = safe if default: prompt += ' [Y/n]? ' else: prompt += ' [y/N]? ' while 1: response = input(prompt).strip() if not response.strip(): return default if response and response[0].lower() in ('y', 'n'): return response[0].lower() == 'y' print('Y or N please') def shorten_filename(self, fn): """ Shortens a filename to make it relative to the current directory (if it can). For display purposes. """ if fn.startswith(os.getcwd() + '/'): fn = fn[len(os.getcwd()) + 1:] return fn def open_editor(self, pretext, breaker=None, extension='.txt'): """ Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after `breaker` will be ignored. """ fn = nowarning_tempnam() + extension f = open(fn, 'w') f.write(pretext) f.close() print('$EDITOR %s' % fn) os.system('$EDITOR %s' % fn) f = open(fn, 'r') content = f.read() f.close() if breaker: content = content.split(breaker)[0] pretext = pretext.split(breaker)[0] if content == pretext or not content.strip(): return None return content class CommandSQL(Command): name = 'sql' summary = 'Show SQL CREATE statements' parser = standard_parser(simulate=False) def command(self): classes = self.classes() allConstraints = [] for cls in classes: if self.options.verbose >= 1: print('-- %s from %s' % ( cls.__name__, cls.__module__)) createSql, constraints = cls.createTableSQL() print(createSql.strip() + ';\n') allConstraints.append(constraints) for constraints in allConstraints: if constraints: for constraint in constraints: if constraint: print(constraint.strip() + ';\n') class CommandList(Command): name = 'list' summary = 'Show all SQLObject classes found' parser = standard_parser(simulate=False, connection=False) def command(self): if self.options.verbose >= 1: print('Classes found:') classes = self.classes(require_connection=False) for soClass in classes: print('%s.%s' % (soClass.__module__, soClass.__name__)) if self.options.verbose >= 1: print(' Table: %s' % soClass.sqlmeta.table) class CommandCreate(Command): name = 'create' summary = 'Create tables' parser = standard_parser(interactive=True) parser.add_option('--create-db', action='store_true', dest='create_db', help="Create the database") def command(self): v = self.options.verbose created = 0 existing = 0 dbs_created = [] constraints = {} for soClass in self.classes(require_some=True): if (self.options.create_db and soClass._connection not in dbs_created): if not self.options.simulate: try: soClass._connection.createEmptyDatabase() except soClass._connection.module.ProgrammingError as e: if str(e).find('already exists') != -1: print('Database already exists') else: raise else: print('(simulating; cannot create database)') dbs_created.append(soClass._connection) if soClass._connection not in constraints.keys(): constraints[soClass._connection] = [] exists = soClass._connection.tableExists(soClass.sqlmeta.table) if v >= 1: if exists: existing += 1 print('%s already exists.' % soClass.__name__) else: print('Creating %s' % soClass.__name__) if v >= 2: sql, extra = soClass.createTableSQL() print(sql) if (not self.options.simulate and not exists): if self.options.interactive: if self.ask('Create %s' % soClass.__name__): created += 1 tableConstraints = soClass.createTable( applyConstraints=False) if tableConstraints: constraints[soClass._connection].append( tableConstraints) else: print('Cancelled') else: created += 1 tableConstraints = soClass.createTable( applyConstraints=False) if tableConstraints: constraints[soClass._connection].append( tableConstraints) for connection in constraints.keys(): if v >= 2: print('Creating constraints') for constraintList in constraints[connection]: for constraint in constraintList: if constraint: connection.query(constraint) if v >= 1: print('%i tables created (%i already exist)' % ( created, existing)) class CommandDrop(Command): name = 'drop' summary = 'Drop tables' parser = standard_parser(interactive=True) def command(self): v = self.options.verbose dropped = 0 not_existing = 0 for soClass in reversed(self.classes()): exists = soClass._connection.tableExists(soClass.sqlmeta.table) if v >= 1: if exists: print('Dropping %s' % soClass.__name__) else: not_existing += 1 print('%s does not exist.' % soClass.__name__) if (not self.options.simulate and exists): if self.options.interactive: if self.ask('Drop %s' % soClass.__name__): dropped += 1 soClass.dropTable() else: print('Cancelled') else: dropped += 1 soClass.dropTable() if v >= 1: print('%i tables dropped (%i didn\'t exist)' % ( dropped, not_existing)) class CommandStatus(Command): name = 'status' summary = 'Show status of classes vs. database' help = ('This command checks the SQLObject definition and checks if ' 'the tables in the database match. It can always test for ' 'missing tables, and on some databases can test for the ' 'existance of other tables. Column types are not currently ' 'checked.') parser = standard_parser(simulate=False) def print_class(self, soClass): if self.printed: return self.printed = True print('Checking %s...' % soClass.__name__) def command(self): good = 0 bad = 0 missing_tables = 0 columnsFromSchema_warning = False for soClass in self.classes(require_some=True): conn = soClass._connection self.printed = False if self.options.verbose: self.print_class(soClass) if not conn.tableExists(soClass.sqlmeta.table): self.print_class(soClass) print(' Does not exist in database') missing_tables += 1 continue try: columns = conn.columnsFromSchema(soClass.sqlmeta.table, soClass) except AttributeError: if not columnsFromSchema_warning: print('Database does not support reading columns') columnsFromSchema_warning = True good += 1 continue except AssertionError as e: print('Cannot read db table %s: %s' % ( soClass.sqlmeta.table, e)) continue existing = {} for _col in columns: _col = _col.withClass(soClass) existing[_col.dbName] = _col missing = {} for _col in soClass.sqlmeta.columnList: if _col.dbName in existing: del existing[_col.dbName] else: missing[_col.dbName] = _col if existing: self.print_class(soClass) for _col in existing.values(): print(' Database has extra column: %s' % _col.dbName) if missing: self.print_class(soClass) for _col in missing.values(): print(' Database missing column: %s' % _col.dbName) if existing or missing: bad += 1 else: good += 1 if self.options.verbose: print('%i in sync; %i out of sync; %i not in database' % ( good, bad, missing_tables)) class CommandHelp(Command): name = 'help' summary = 'Show help' parser = optparse.OptionParser() max_args = 1 def command(self): if self.args: the_runner.run([self.invoked_as, self.args[0], '-h']) else: print('Available commands:') print(' (use "%s help COMMAND" or "%s COMMAND -h" ' % ( self.prog_name, self.prog_name)) print(' for more information)') items = sorted(the_runner.commands.items()) max_len = max([len(cn) for cn, c in items]) for command_name, command in items: print('%s:%s %s' % (command_name, ' ' * (max_len - len(command_name)), command.summary)) if command.aliases: print('%s (Aliases: %s)' % ( ' ' * max_len, ', '.join(command.aliases))) class CommandExecute(Command): name = 'execute' summary = 'Execute SQL statements' help = ('Runs SQL statements directly in the database, with no ' 'intervention. Useful when used with a configuration file. ' 'Each argument is executed as an individual statement.') parser = standard_parser(find_modules=False) parser.add_option('--stdin', help="Read SQL from stdin " "(normally takes SQL from the command line)", dest="use_stdin", action="store_true") max_args = None def command(self): args = self.args if self.options.use_stdin: if self.options.verbose: print("Reading additional SQL from stdin " "(Ctrl-D or Ctrl-Z to finish)...") args.append(sys.stdin.read()) self.conn = self.connection().getConnection() self.cursor = self.conn.cursor() for sql in args: self.execute_sql(sql) def execute_sql(self, sql): if self.options.verbose: print(sql) try: self.cursor.execute(sql) except Exception as e: if not self.options.verbose: print(sql) print("****Error:") print(' ', e) return desc = self.cursor.description rows = self.cursor.fetchall() if self.options.verbose: if not self.cursor.rowcount: print("No rows accessed") else: print("%i rows accessed" % self.cursor.rowcount) if desc: for (name, type_code, display_size, internal_size, precision, scale, null_ok) in desc: sys.stdout.write("%s\t" % name) sys.stdout.write("\n") for row in rows: for _col in row: sys.stdout.write("%r\t" % _col) sys.stdout.write("\n") print() class CommandRecord(Command): name = 'record' summary = 'Record historical information about the database status' help = ('Record state of table definitions. The state of each ' 'table is written out to a separate file in a directory, ' 'and that directory forms a "version". A table is also ' 'added to your database (%s) that reflects the version the ' 'database is currently at. Use the upgrade command to ' 'sync databases with code.' % SQLObjectVersionTable.sqlmeta.table) parser = standard_parser() parser.add_option('--output-dir', help="Base directory for recorded definitions", dest="output_dir", metavar="DIR", default=None) parser.add_option('--no-db-record', help="Don't record version to database", dest="db_record", action="store_false", default=True) parser.add_option('--force-create', help="Create a new version even if appears to be " "identical to the last version", action="store_true", dest="force_create") parser.add_option('--name', help="The name to append to the version. The " "version should sort after previous versions (so " "any versions from the same day should come " "alphabetically before this version).", dest="version_name", metavar="NAME") parser.add_option('--force-db-version', help="Update the database version, and include no " "database information. This is for databases that " "were developed without any interaction with " "this tool, to create a 'beginning' revision.", metavar="VERSION_NAME", dest="force_db_version") parser.add_option('--edit', help="Open an editor for the upgrader in the last " "version (using $EDITOR).", action="store_true", dest="open_editor") version_regex = re.compile(r'^\d\d\d\d-\d\d-\d\d') def command(self): if self.options.force_db_version: self.command_force_db_version() return v = self.options.verbose sim = self.options.simulate classes = self.classes() if not classes: print("No classes found!") return output_dir = self.find_output_dir() version = os.path.basename(output_dir) print("Creating version %s" % version) conns = [] files = {} for cls in self.classes(): dbName = cls._connection.dbName if cls._connection not in conns: conns.append(cls._connection) fn = os.path.join(cls.__name__ + '_' + dbName + '.sql') if sim: continue create, constraints = cls.createTableSQL() if constraints: constraints = '\n-- Constraints:\n%s\n' % ( '\n'.join(constraints)) else: constraints = '' files[fn] = ''.join([ '-- Exported definition from %s\n' % time.strftime('%Y-%m-%dT%H:%M:%S'), '-- Class %s.%s\n' % (cls.__module__, cls.__name__), '-- Database: %s\n' % dbName, create.strip(), '\n', constraints]) last_version_dir = self.find_last_version() if last_version_dir and not self.options.force_create: if v > 1: print("Checking %s to see if it is current" % last_version_dir) files_copy = files.copy() for fn in os.listdir(last_version_dir): if not fn.endswith('.sql'): continue if fn not in files_copy: if v > 1: print("Missing file %s" % fn) break f = open(os.path.join(last_version_dir, fn), 'r') content = f.read() f.close() if (self.strip_comments(files_copy[fn]) != self.strip_comments(content)): if v > 1: print("Content does not match: %s" % fn) break del files_copy[fn] else: # No differences so far if not files_copy: # Used up all files print("Current status matches version %s" % os.path.basename(last_version_dir)) return if v > 1: print("Extra files: %s" % ', '.join(files_copy.keys())) if v: print("Current state does not match %s" % os.path.basename(last_version_dir)) if v > 1 and not last_version_dir: print("No last version to check") if not sim: os.mkdir(output_dir) if v: print('Making directory %s' % self.shorten_filename(output_dir)) files = sorted(files.items()) for fn, content in files: if v: print(' Writing %s' % self.shorten_filename(fn)) if not sim: f = open(os.path.join(output_dir, fn), 'w') f.write(content) f.close() if self.options.db_record: all_diffs = [] for cls in self.classes(): for conn in conns: diffs = db_differences(cls, conn) for diff in diffs: if len(conns) > 1: diff = ' (%s).%s: %s' % ( conn.uri(), cls.sqlmeta.table, diff) else: diff = ' %s: %s' % (cls.sqlmeta.table, diff) all_diffs.append(diff) if all_diffs: print('Database does not match schema:') print('\n'.join(all_diffs)) for conn in conns: self.update_db(version, conn) else: all_diffs = [] if self.options.open_editor: if not last_version_dir: print("Cannot edit upgrader because there is no " "previous version") else: breaker = ('-' * 20 + ' lines below this will be ignored ' + '-' * 20) pre_text = breaker + '\n' + '\n'.join(all_diffs) text = self.open_editor('\n\n' + pre_text, breaker=breaker, extension='.sql') if text is not None: fn = os.path.join(last_version_dir, 'upgrade_%s_%s.sql' % (dbName, version)) f = open(fn, 'w') f.write(text) f.close() print('Wrote to %s' % fn) def update_db(self, version, conn): v = self.options.verbose if not conn.tableExists(SQLObjectVersionTable.sqlmeta.table): if v: print('Creating table %s' % SQLObjectVersionTable.sqlmeta.table) sql = SQLObjectVersionTable.createTableSQL(connection=conn) if v > 1: print(sql) if not self.options.simulate: SQLObjectVersionTable.createTable(connection=conn) if not self.options.simulate: SQLObjectVersionTable.clearTable(connection=conn) SQLObjectVersionTable( version=version, connection=conn) def strip_comments(self, sql): lines = [l for l in sql.splitlines() if not l.strip().startswith('--')] return '\n'.join(lines) def base_dir(self): base = self.options.output_dir if base is None: config = self.config() if config is not None: base = config.get('sqlobject_history_dir', '.') else: base = '.' if not os.path.exists(base): print('Creating history directory %s' % self.shorten_filename(base)) if not self.options.simulate: os.makedirs(base) return base def find_output_dir(self): today = time.strftime('%Y-%m-%d', time.localtime()) if self.options.version_name: dir = os.path.join(self.base_dir(), today + '-' + self.options.version_name) if os.path.exists(dir): print("Error, directory already exists: %s" % dir) sys.exit(1) return dir extra = '' while 1: dir = os.path.join(self.base_dir(), today + extra) if not os.path.exists(dir): return dir if not extra: extra = 'a' else: extra = chr(ord(extra) + 1) def find_last_version(self): names = [] for fn in os.listdir(self.base_dir()): if not self.version_regex.search(fn): continue names.append(fn) if not names: return None names.sort() return os.path.join(self.base_dir(), names[-1]) def command_force_db_version(self): v = self.options.verbose sim = self.options.simulate version = self.options.force_db_version if not self.version_regex.search(version): print("Versions must be in the format YYYY-MM-DD...") print("You version %s does not fit this" % version) return version_dir = os.path.join(self.base_dir(), version) if not os.path.exists(version_dir): if v: print('Creating %s' % self.shorten_filename(version_dir)) if not sim: os.mkdir(version_dir) elif v: print('Directory %s exists' % self.shorten_filename(version_dir)) if self.options.db_record: self.update_db(version, self.connection()) class CommandUpgrade(CommandRecord): name = 'upgrade' summary = 'Update the database to a new version (as created by record)' help = ('This command runs scripts (that you write by hand) to ' 'upgrade a database. The database\'s current version is in ' 'the sqlobject_version table (use record --force-db-version ' 'if a database does not have a sqlobject_version table), ' 'and upgrade scripts are in the version directory you are ' 'upgrading FROM, named upgrade_DBNAME_VERSION.sql, like ' '"upgrade_mysql_2004-12-01b.sql".') parser = standard_parser(find_modules=False) parser.add_option('--upgrade-to', help="Upgrade to the given version " "(default: newest version)", dest="upgrade_to", metavar="VERSION") parser.add_option('--output-dir', help="Base directory for recorded definitions", dest="output_dir", metavar="DIR", default=None) upgrade_regex = re.compile(r'^upgrade_([a-z]*)_([^.]*)\.sql$', re.I) def command(self): v = self.options.verbose sim = self.options.simulate if self.options.upgrade_to: version_to = self.options.upgrade_to else: fname = self.find_last_version() if fname is None: print("No version exists, use 'record' command to create one") return version_to = os.path.basename(fname) current = self.current_version() if v: print('Current version: %s' % current) version_list = self.make_plan(current, version_to) if not version_list: print('Database up to date') return if v: print('Plan:') for next_version, upgrader in version_list: print(' Use %s to upgrade to %s' % ( self.shorten_filename(upgrader), next_version)) conn = self.connection() for next_version, upgrader in version_list: f = open(upgrader) sql = f.read() f.close() if v: print("Running:") print(sql) print('-' * 60) if not sim: try: conn.query(sql) except: print("Error in script: %s" % upgrader) raise self.update_db(next_version, conn) print('Done.') def current_version(self): conn = self.connection() if not conn.tableExists(SQLObjectVersionTable.sqlmeta.table): print('No sqlobject_version table!') sys.exit(1) versions = list(SQLObjectVersionTable.select(connection=conn)) if not versions: print('No rows in sqlobject_version!') sys.exit(1) if len(versions) > 1: print('Ambiguous sqlobject_version_table') sys.exit(1) return versions[0].version def make_plan(self, current, dest): if current == dest: return [] dbname = self.connection().dbName next_version, upgrader = self.best_upgrade(current, dest, dbname) if not upgrader: print('No way to upgrade from %s to %s' % (current, dest)) print('(you need a %s/upgrade_%s_%s.sql script)' % (current, dbname, dest)) sys.exit(1) plan = [(next_version, upgrader)] if next_version == dest: return plan else: return plan + self.make_plan(next_version, dest) def best_upgrade(self, current, dest, target_dbname): current_dir = os.path.join(self.base_dir(), current) if self.options.verbose > 1: print('Looking in %s for upgraders' % self.shorten_filename(current_dir)) upgraders = [] for fn in os.listdir(current_dir): match = self.upgrade_regex.search(fn) if not match: if self.options.verbose > 1: print('Not an upgrade script: %s' % fn) continue dbname = match.group(1) version = match.group(2) if dbname != target_dbname: if self.options.verbose > 1: print('Not for this database: %s (want %s)' % ( dbname, target_dbname)) continue if version > dest: if self.options.verbose > 1: print('Version too new: %s (only want %s)' % ( version, dest)) upgraders.append((version, os.path.join(current_dir, fn))) if not upgraders: if self.options.verbose > 1: print('No upgraders found in %s' % current_dir) return None, None upgraders.sort() return upgraders[-1] def update_sys_path(paths, verbose): if isinstance(paths, string_type): paths = [paths] for path in paths: path = os.path.abspath(path) if path not in sys.path: if verbose > 1: print('Adding %s to path' % path) sys.path.insert(0, path) if __name__ == '__main__': the_runner.run(sys.argv) SQLObject-3.1.0/sqlobject/__init__.py0000644000175000017500000000075212464226042016756 0ustar phdphd00000000000000"""SQLObject""" # Do import for namespace # noqa is a directive for flake8 to ignore seemingly unused imports from .__version__ import version, version_info # noqa from .col import * # noqa from .index import * # noqa from .joins import * # noqa from .main import * # noqa from .sqlbuilder import AND, OR, NOT, IN, LIKE, RLIKE, DESC, CONTAINSSTRING, const, func # noqa from .styles import * # noqa from .dbconnection import connectionForURI # noqa from . import dberrors # noqa SQLObject-3.1.0/sqlobject/__version__.py0000644000175000017500000000022012754656750017505 0ustar phdphd00000000000000 version = '3.1.0' major = 3 minor = 1 micro = 0 release_level = 'final' serial = 0 version_info = (major, minor, micro, release_level, serial) SQLObject-3.1.0/sqlobject/inheritance/0000755000175000017500000000000012754657361017150 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/inheritance/__init__.py0000644000175000017500000005677712471401471021270 0ustar phdphd00000000000000from functools import reduce from sqlobject import dbconnection from sqlobject import classregistry from sqlobject import events from sqlobject import sqlbuilder from sqlobject.col import StringCol, ForeignKey from sqlobject.main import sqlmeta, SQLObject, SelectResults, \ makeProperties, unmakeProperties, getterName, setterName from sqlobject.compat import string_type from . import iteration def tablesUsedSet(obj, db): if hasattr(obj, "tablesUsedSet"): return obj.tablesUsedSet(db) elif isinstance(obj, (tuple, list, set, frozenset)): s = set() for component in obj: s.update(tablesUsedSet(component, db)) return s else: return set() class InheritableSelectResults(SelectResults): IterationClass = iteration.InheritableIteration def __init__(self, sourceClass, clause, clauseTables=None, inheritedTables=None, **ops): if clause is None or isinstance(clause, str) and clause == 'all': clause = sqlbuilder.SQLTrueClause dbName = (ops.get('connection', None) or sourceClass._connection).dbName tablesSet = tablesUsedSet(clause, dbName) tablesSet.add(str(sourceClass.sqlmeta.table)) orderBy = ops.get('orderBy') if inheritedTables: for tableName in inheritedTables: tablesSet.add(str(tableName)) if orderBy and not isinstance(orderBy, string_type): tablesSet.update(tablesUsedSet(orderBy, dbName)) # DSM: if this class has a parent, we need to link it # DSM: and be sure the parent is in the table list. # DSM: The following code is before clauseTables # DSM: because if the user uses clauseTables # DSM: (and normal string SELECT), he must know what he wants # DSM: and will do himself the relationship between classes. if not isinstance(clause, str): tableRegistry = {} allClasses = classregistry.registry( sourceClass.sqlmeta.registry).allClasses() for registryClass in allClasses: if str(registryClass.sqlmeta.table) in tablesSet: # DSM: By default, no parents are needed for the clauses tableRegistry[registryClass] = registryClass tableRegistryCopy = tableRegistry.copy() for childClass in tableRegistryCopy: if childClass not in tableRegistry: continue currentClass = childClass while currentClass: if currentClass in tableRegistryCopy: if currentClass in tableRegistry: # DSM: Remove this class as it is a parent one # DSM: of a needed children del tableRegistry[currentClass] # DSM: Must keep the last parent needed # DSM: (to limit the number of join needed) tableRegistry[childClass] = currentClass currentClass = currentClass.sqlmeta.parentClass # DSM: Table registry contains only the last children # DSM: or standalone classes parentClause = [] for (currentClass, minParentClass) in tableRegistry.items(): while (currentClass != minParentClass) \ and currentClass.sqlmeta.parentClass: parentClass = currentClass.sqlmeta.parentClass parentClause.append(currentClass.q.id == parentClass.q.id) currentClass = parentClass tablesSet.add(str(currentClass.sqlmeta.table)) clause = reduce(sqlbuilder.AND, parentClause, clause) super(InheritableSelectResults, self).__init__( sourceClass, clause, clauseTables, **ops) def accumulateMany(self, *attributes, **kw): if kw.get("skipInherited"): return super(InheritableSelectResults, self).\ accumulateMany(*attributes) tables = [] for func_name, attribute in attributes: if not isinstance(attribute, string_type): tables.append(attribute.tableName) clone = self.__class__(self.sourceClass, self.clause, self.clauseTables, inheritedTables=tables, **self.ops) return clone.accumulateMany(skipInherited=True, *attributes) class InheritableSQLMeta(sqlmeta): @classmethod def addColumn(sqlmeta, columnDef, changeSchema=False, connection=None, childUpdate=False): soClass = sqlmeta.soClass # DSM: Try to add parent properties to the current class # DSM: Only do this once if possible at object creation and once for # DSM: each new dynamic column to refresh the current class if sqlmeta.parentClass: for col in sqlmeta.parentClass.sqlmeta.columnList: cname = col.name if cname == 'childName': continue if cname.endswith("ID"): cname = cname[:-2] setattr(soClass, getterName(cname), eval( 'lambda self: self._parent.%s' % cname)) if not col.immutable: def make_setfunc(cname): def setfunc(self, val): if not self.sqlmeta._creating and \ not getattr(self.sqlmeta, "row_update_sig_suppress", False): self.sqlmeta.send(events.RowUpdateSignal, self, {cname: val}) setattr(self._parent, cname, val) return setfunc setfunc = make_setfunc(cname) setattr(soClass, setterName(cname), setfunc) if childUpdate: makeProperties(soClass) return if columnDef: super(InheritableSQLMeta, sqlmeta).addColumn(columnDef, changeSchema, connection) # DSM: Update each child class if needed and existing (only for new # DSM: dynamic column as no child classes exists at object creation) if columnDef and hasattr(soClass, "q"): q = getattr(soClass.q, columnDef.name, None) else: q = None for c in sqlmeta.childClasses.values(): c.sqlmeta.addColumn(columnDef, connection=connection, childUpdate=True) if q: setattr(c.q, columnDef.name, q) @classmethod def delColumn(sqlmeta, column, changeSchema=False, connection=None, childUpdate=False): if childUpdate: soClass = sqlmeta.soClass unmakeProperties(soClass) makeProperties(soClass) if isinstance(column, str): name = column else: name = column.name delattr(soClass, name) delattr(soClass.q, name) return super(InheritableSQLMeta, sqlmeta).delColumn(column, changeSchema, connection) # DSM: Update each child class if needed # DSM: and delete properties for this column for c in sqlmeta.childClasses.values(): c.sqlmeta.delColumn(column, changeSchema=changeSchema, connection=connection, childUpdate=True) @classmethod def addJoin(sqlmeta, joinDef, childUpdate=False): soClass = sqlmeta.soClass # DSM: Try to add parent properties to the current class # DSM: Only do this once if possible at object creation and once for # DSM: each new dynamic join to refresh the current class if sqlmeta.parentClass: for join in sqlmeta.parentClass.sqlmeta.joins: jname = join.joinMethodName jarn = join.addRemoveName setattr( soClass, getterName(jname), eval('lambda self: self._parent.%s' % jname)) if hasattr(join, 'remove'): setattr( soClass, 'remove' + jarn, eval('lambda self,o: self._parent.remove%s(o)' % jarn)) if hasattr(join, 'add'): setattr( soClass, 'add' + jarn, eval('lambda self,o: self._parent.add%s(o)' % jarn)) if childUpdate: makeProperties(soClass) return if joinDef: super(InheritableSQLMeta, sqlmeta).addJoin(joinDef) # DSM: Update each child class if needed and existing (only for new # DSM: dynamic join as no child classes exists at object creation) for c in sqlmeta.childClasses.values(): c.sqlmeta.addJoin(joinDef, childUpdate=True) @classmethod def delJoin(sqlmeta, joinDef, childUpdate=False): if childUpdate: soClass = sqlmeta.soClass unmakeProperties(soClass) makeProperties(soClass) return super(InheritableSQLMeta, sqlmeta).delJoin(joinDef) # DSM: Update each child class if needed # DSM: and delete properties for this join for c in sqlmeta.childClasses.values(): c.sqlmeta.delJoin(joinDef, childUpdate=True) @classmethod def getAllColumns(sqlmeta): columns = sqlmeta.columns.copy() sm = sqlmeta while sm.parentClass: columns.update(sm.parentClass.sqlmeta.columns) sm = sm.parentClass.sqlmeta return columns @classmethod def getColumns(sqlmeta): columns = sqlmeta.getAllColumns() if 'childName' in columns: del columns['childName'] return columns class InheritableSQLObject(SQLObject): sqlmeta = InheritableSQLMeta _inheritable = True SelectResultsClass = InheritableSelectResults def set(self, **kw): if self._parent: SQLObject.set(self, _suppress_set_sig=True, **kw) else: SQLObject.set(self, **kw) def __classinit__(cls, new_attrs): SQLObject.__classinit__(cls, new_attrs) # if we are a child class, add sqlbuilder fields from parents currentClass = cls.sqlmeta.parentClass while currentClass: for column in currentClass.sqlmeta.columnDefinitions.values(): if column.name == 'childName': continue if isinstance(column, ForeignKey): continue setattr(cls.q, column.name, getattr(currentClass.q, column.name)) currentClass = currentClass.sqlmeta.parentClass @classmethod def _SO_setupSqlmeta(cls, new_attrs, is_base): # Note: cannot use super(InheritableSQLObject, cls)._SO_setupSqlmeta - # InheritableSQLObject is not defined when it's __classinit__ # is run. Cannot use SQLObject._SO_setupSqlmeta, either: # the method would be bound to wrong class. if cls.__name__ == "InheritableSQLObject": call_super = super(cls, cls) else: # InheritableSQLObject must be in globals yet call_super = super(InheritableSQLObject, cls) call_super._SO_setupSqlmeta(new_attrs, is_base) sqlmeta = cls.sqlmeta sqlmeta.childClasses = {} # locate parent class and register this class in it's children sqlmeta.parentClass = None for superclass in cls.__bases__: if getattr(superclass, '_inheritable', False) \ and (superclass.__name__ != 'InheritableSQLObject'): if sqlmeta.parentClass: # already have a parent class; # cannot inherit from more than one raise NotImplementedError( "Multiple inheritance is not implemented") sqlmeta.parentClass = superclass superclass.sqlmeta.childClasses[cls.__name__] = cls if sqlmeta.parentClass: # remove inherited column definitions cls.sqlmeta.columns = {} cls.sqlmeta.columnList = [] cls.sqlmeta.columnDefinitions = {} # default inheritance child name if not sqlmeta.childName: sqlmeta.childName = cls.__name__ @classmethod def get(cls, id, connection=None, selectResults=None, childResults=None, childUpdate=False): val = super(InheritableSQLObject, cls).get(id, connection, selectResults) # DSM: If we are updating a child, we should never return a child... if childUpdate: return val # DSM: If this class has a child, return the child if 'childName' in cls.sqlmeta.columns: childName = val.childName if childName is not None: childClass = cls.sqlmeta.childClasses[childName] # If the class has no columns (which sometimes makes sense # and may be true for non-inheritable (leaf) classes only), # shunt the query to avoid almost meaningless SQL # like "SELECT NULL FROM child WHERE id=1". # This is based on assumption that child object exists # if parent object exists. (If it doesn't your database # is broken and that is a job for database maintenance.) if not (childResults or childClass.sqlmeta.columns): childResults = (None,) return childClass.get(id, connection=connection, selectResults=childResults) # DSM: Now, we know we are alone or the last child in a family... # DSM: It's time to find our parents inst = val while inst.sqlmeta.parentClass and not inst._parent: inst._parent = inst.sqlmeta.parentClass.get( id, connection=connection, childUpdate=True) inst = inst._parent # DSM: We can now return ourself return val @classmethod def _notifyFinishClassCreation(cls): sqlmeta = cls.sqlmeta # verify names of added columns if sqlmeta.parentClass: # FIXME: this does not check for grandparent column overrides parentCols = sqlmeta.parentClass.sqlmeta.columns.keys() for column in sqlmeta.columnList: if column.name == 'childName': raise AttributeError( "The column name 'childName' is reserved") if column.name in parentCols: raise AttributeError( "The column '%s' is already defined " "in an inheritable parent" % column.name) # if this class is inheritable, add column for children distinction if cls._inheritable and (cls.__name__ != 'InheritableSQLObject'): sqlmeta.addColumn( StringCol(name='childName', # limit string length to get VARCHAR and not CLOB length=255, default=None)) if not sqlmeta.columnList: # There are no columns - call addColumn to propagate columns # from parent classes to children sqlmeta.addColumn(None) if not sqlmeta.joins: # There are no joins - call addJoin to propagate joins # from parent classes to children sqlmeta.addJoin(None) def _create(self, id, **kw): # DSM: If we were called by a children class, # DSM: we must retreive the properties dictionary. # DSM: Note: we can't use the ** call paremeter directly # DSM: as we must be able to delete items from the dictionary # DSM: (and our children must know that the items were removed!) if 'kw' in kw: kw = kw['kw'] # DSM: If we are the children of an inheritable class, # DSM: we must first create our parent if self.sqlmeta.parentClass: parentClass = self.sqlmeta.parentClass new_kw = {} parent_kw = {} for (name, value) in kw.items(): if (name != 'childName') and hasattr(parentClass, name): parent_kw[name] = value else: new_kw[name] = value kw = new_kw # Need to check that we have enough data to sucesfully # create the current subclass otherwise we will leave # the database in an inconsistent state. for col in self.sqlmeta.columnList: if (col._default == sqlbuilder.NoDefault) and \ (col.name not in kw) and (col.foreignName not in kw): raise TypeError( "%s() did not get expected keyword argument " "%s" % (self.__class__.__name__, col.name)) parent_kw['childName'] = self.sqlmeta.childName self._parent = parentClass(kw=parent_kw, connection=self._connection) id = self._parent.id # TC: Create this record and catch all exceptions in order to destroy # TC: the parent if the child can not be created. try: super(InheritableSQLObject, self)._create(id, **kw) except: # If we are outside a transaction and this is a child, # destroy the parent connection = self._connection if (not isinstance(connection, dbconnection.Transaction) and connection.autoCommit) and self.sqlmeta.parentClass: self._parent.destroySelf() # TC: Do we need to do this?? self._parent = None # TC: Reraise the original exception raise @classmethod def _findAlternateID(cls, name, dbName, value, connection=None): result = list(cls.selectBy(connection, **{name: value})) if not result: return result, None obj = result[0] return [obj.id], obj @classmethod def select(cls, clause=None, *args, **kwargs): parentClass = cls.sqlmeta.parentClass childUpdate = kwargs.pop('childUpdate', None) # childUpdate may have one of three values: # True: # select was issued by parent class to create child objects. # Execute select without modifications. # None (default): # select is run by application. If this class is inheritance # child, delegate query to the parent class to utilize # InheritableIteration optimizations. Selected records # are restricted to this (child) class by adding childName # filter to the where clause. # False: # select is delegated from inheritance child which is parent # of another class. Delegate the query to parent if possible, # but don't add childName restriction: selected records # will be filtered by join to the table filtered by childName. if (not childUpdate) and parentClass: if childUpdate is None: # this is the first parent in deep hierarchy addClause = parentClass.q.childName == cls.sqlmeta.childName # if the clause was one of TRUE varians, replace it if (clause is None) or (clause is sqlbuilder.SQLTrueClause) \ or ( isinstance(clause, string_type) and (clause == 'all')): clause = addClause else: # patch WHERE condition: # change ID field of this class to ID of parent class # XXX the clause is patched in place; it would be better # to build a new one if we have to replace field clsID = cls.q.id parentID = parentClass.q.id def _get_patched(clause): if isinstance(clause, sqlbuilder.SQLOp): _patch_id_clause(clause) return None elif not isinstance(clause, sqlbuilder.Field): return None elif (clause.tableName == clsID.tableName) \ and (clause.fieldName == clsID.fieldName): return parentID else: return None def _patch_id_clause(clause): if not isinstance(clause, sqlbuilder.SQLOp): return expr = _get_patched(clause.expr1) if expr: clause.expr1 = expr expr = _get_patched(clause.expr2) if expr: clause.expr2 = expr _patch_id_clause(clause) # add childName filter clause = sqlbuilder.AND(clause, addClause) return parentClass.select(clause, childUpdate=False, *args, **kwargs) else: return super(InheritableSQLObject, cls).select( clause, *args, **kwargs) @classmethod def selectBy(cls, connection=None, **kw): clause = [] foreignColumns = {} currentClass = cls while currentClass: foreignColumns.update(dict( [(column.foreignName, name) for (name, column) in currentClass.sqlmeta.columns.items() if column.foreignKey ])) currentClass = currentClass.sqlmeta.parentClass for name, value in kw.items(): if name in foreignColumns: name = foreignColumns[name] # translate "key" to "keyID" if isinstance(value, SQLObject): value = value.id currentClass = cls while currentClass: try: clause.append(getattr(currentClass.q, name) == value) break except AttributeError: pass currentClass = currentClass.sqlmeta.parentClass else: raise AttributeError( "'%s' instance has no attribute '%s'" % ( cls.__name__, name)) if clause: clause = reduce(sqlbuilder.AND, clause) else: clause = None # select all conn = connection or cls._connection return cls.SelectResultsClass(cls, clause, connection=conn) def destroySelf(self): # DSM: If this object has parents, recursivly kill them if hasattr(self, '_parent') and self._parent: self._parent.destroySelf() super(InheritableSQLObject, self).destroySelf() def _reprItems(self): items = super(InheritableSQLObject, self)._reprItems() # add parent attributes (if any) if self.sqlmeta.parentClass: items.extend(self._parent._reprItems()) # filter out our special column return [item for item in items if item[0] != 'childName'] __all__ = ['InheritableSQLObject'] SQLObject-3.1.0/sqlobject/inheritance/tests/0000755000175000017500000000000012754657361020312 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/inheritance/tests/test_aggregates.py0000644000175000017500000000121412747416060024021 0ustar phdphd00000000000000from sqlobject import IntCol from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import raises, setupClass class TestAggregate1(InheritableSQLObject): value1 = IntCol() class TestAggregate2(TestAggregate1): value2 = IntCol() def test_aggregates(): setupClass([TestAggregate1, TestAggregate2]) TestAggregate1(value1=1) TestAggregate2(value1=2, value2=12) assert TestAggregate1.select().max("value1") == 2 assert TestAggregate2.select().max("value1") == 2 raises(Exception, TestAggregate2.select().max, "value2") assert TestAggregate2.select().max(TestAggregate2.q.value2) == 12 SQLObject-3.1.0/sqlobject/inheritance/tests/__init__.py0000644000175000017500000000000210202735006022366 0ustar phdphd00000000000000# SQLObject-3.1.0/sqlobject/inheritance/tests/test_inheritance.py0000644000175000017500000001113512747416060024204 0ustar phdphd00000000000000from py.test import raises from sqlobject import IntCol, StringCol from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import setupClass ######################################## # Inheritance ######################################## class InheritablePerson(InheritableSQLObject): firstName = StringCol() lastName = StringCol(alternateID=True, length=255) class Employee(InheritablePerson): _inheritable = False position = StringCol() def setup(): setupClass(InheritablePerson) setupClass(Employee) Employee(firstName='Project', lastName='Leader', position='Project leader') InheritablePerson(firstName='Oneof', lastName='Authors') def test_creation_fail(): setup() kwargs = {'firstName': 'John', 'lastname': 'Doe'} raises(TypeError, Employee, **kwargs) persons = InheritablePerson.select(InheritablePerson.q.firstName == 'John') assert persons.count() == 0 def test_inheritance(): setup() persons = InheritablePerson.select() # all for person in persons: assert isinstance(person, InheritablePerson) if isinstance(person, Employee): assert not hasattr(person, "childName") else: assert hasattr(person, "childName") assert not person.childName def test_inheritance_select(): setup() # comparison to None needed to build the right SQL expression persons = InheritablePerson.select( InheritablePerson.q.firstName != None) # noqa assert persons.count() == 2 persons = InheritablePerson.select(InheritablePerson.q.firstName == "phd") assert persons.count() == 0 # comparison to None needed to build the right SQL expression employees = Employee.select(Employee.q.firstName != None) # noqa assert employees.count() == 1 employees = Employee.select(Employee.q.firstName == "phd") assert employees.count() == 0 # comparison to None needed to build the right SQL expression employees = Employee.select(Employee.q.position != None) # noqa assert employees.count() == 1 persons = InheritablePerson.selectBy(firstName="Project") assert persons.count() == 1 assert isinstance(persons[0], Employee) persons = Employee.selectBy(firstName="Project") assert persons.count() == 1 try: person = InheritablePerson.byLastName("Oneof") except: pass else: raise RuntimeError("unknown person %s" % person) person = InheritablePerson.byLastName("Leader") assert person.firstName == "Project" person = Employee.byLastName("Leader") assert person.firstName == "Project" persons = list(InheritablePerson.select( orderBy=InheritablePerson.q.lastName)) assert len(persons) == 2 persons = list(InheritablePerson.select(orderBy=( InheritablePerson.q.lastName, InheritablePerson.q.firstName))) assert len(persons) == 2 persons = list(Employee.select(orderBy=Employee.q.lastName)) assert len(persons) == 1 persons = list(Employee.select(orderBy=(Employee.q.lastName, Employee.q.firstName))) assert len(persons) == 1 persons = list(Employee.select(orderBy=Employee.q.position)) assert len(persons) == 1 persons = list(Employee.select(orderBy=(Employee.q.position, Employee.q.lastName))) assert len(persons) == 1 def test_addDelColumn(): setup() assert hasattr(InheritablePerson, "firstName") assert hasattr(Employee, "firstName") assert hasattr(InheritablePerson.q, "firstName") assert hasattr(Employee.q, "firstName") Employee.sqlmeta.addColumn(IntCol('runtime', default=None)) assert not hasattr(InheritablePerson, 'runtime') assert hasattr(Employee, 'runtime') assert not hasattr(InheritablePerson.q, 'runtime') assert hasattr(Employee.q, 'runtime') InheritablePerson.sqlmeta.addColumn(IntCol('runtime2', default=None)) assert hasattr(InheritablePerson, 'runtime2') assert hasattr(Employee, 'runtime2') assert hasattr(InheritablePerson.q, 'runtime2') assert hasattr(Employee.q, 'runtime2') Employee.sqlmeta.delColumn('runtime') assert not hasattr(InheritablePerson, 'runtime') assert not hasattr(Employee, 'runtime') assert not hasattr(InheritablePerson.q, 'runtime') assert not hasattr(Employee.q, 'runtime') InheritablePerson.sqlmeta.delColumn('runtime2') assert not hasattr(InheritablePerson, 'runtime2') assert not hasattr(Employee, 'runtime2') assert not hasattr(InheritablePerson.q, 'runtime2') assert not hasattr(Employee.q, 'runtime2') SQLObject-3.1.0/sqlobject/inheritance/tests/test_deep_inheritance.py0000644000175000017500000000650712747416060025210 0ustar phdphd00000000000000from py.test import raises, skip from sqlobject import ForeignKey, MultipleJoin, StringCol from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import getConnection, setupClass, supports ######################################## # Deep Inheritance ######################################## class DIPerson(InheritableSQLObject): firstName = StringCol(length=100) lastName = StringCol(alternateID=True, length=255) manager = ForeignKey("DIManager", default=None) class DIEmployee(DIPerson): position = StringCol(unique=True, length=100) class DIManager(DIEmployee): subdudes = MultipleJoin("DIPerson", joinColumn="manager_id") def test_creation_fail(): """ Try to create a Manager without specifying a position. This should fail without leaving any partial records in the database. """ setupClass([DIManager, DIEmployee, DIPerson]) kwargs = {'firstName': 'John', 'lastname': 'Doe'} raises(TypeError, DIManager, **kwargs) persons = DIEmployee.select(DIPerson.q.firstName == 'John') assert persons.count() == 0 def test_creation_fail2(): """ Try to create two Managers with the same position. This should fail without leaving any partial records in the database. """ setupClass([DIManager, DIEmployee, DIPerson]) kwargs = {'firstName': 'John', 'lastName': 'Doe', 'position': 'Project Manager'} DIManager(**kwargs) persons = DIEmployee.select(DIPerson.q.firstName == 'John') assert persons.count() == 1 kwargs = {'firstName': 'John', 'lastName': 'Doe II', 'position': 'Project Manager'} raises(Exception, DIManager, **kwargs) persons = DIPerson.select(DIPerson.q.firstName == 'John') assert persons.count() == 1 if not supports('transactions'): skip("Transactions aren't supported") transaction = DIPerson._connection.transaction() kwargs = {'firstName': 'John', 'lastName': 'Doe III', 'position': 'Project Manager'} raises(Exception, DIManager, connection=transaction, **kwargs) transaction.rollback() transaction.begin() persons = DIPerson.select(DIPerson.q.firstName == 'John', connection=transaction) assert persons.count() == 1 def test_deep_inheritance(): setupClass([DIManager, DIEmployee, DIPerson]) manager = DIManager(firstName='Project', lastName='Manager', position='Project Manager') manager_id = manager.id employee_id = DIEmployee(firstName='Project', lastName='Leader', position='Project leader', manager=manager).id DIPerson(firstName='Oneof', lastName='Authors', manager=manager) conn = getConnection() cache = conn.cache cache.clear() managers = list(DIManager.select()) assert len(managers) == 1 cache.clear() employees = list(DIEmployee.select()) assert len(employees) == 2 cache.clear() persons = list(DIPerson.select()) assert len(persons) == 3 cache.clear() person = DIPerson.get(employee_id) assert isinstance(person, DIEmployee) person = DIPerson.get(manager_id) assert isinstance(person, DIEmployee) assert isinstance(person, DIManager) cache.clear() person = DIEmployee.get(manager_id) assert isinstance(person, DIManager) conn.close() SQLObject-3.1.0/sqlobject/inheritance/tests/test_foreignKey.py0000644000175000017500000000541112747416060024015 0ustar phdphd00000000000000from sqlobject import ForeignKey, SQLObject, StringCol from sqlobject.tests.dbtest import setupClass from sqlobject.inheritance import InheritableSQLObject class Note(SQLObject): text = StringCol() class PersonWithNotes(InheritableSQLObject): firstName = StringCol() lastName = StringCol() note = ForeignKey("Note", default=None) class Paper(SQLObject): content = StringCol() class EmployeeWithNotes(PersonWithNotes): _inheritable = False paper = ForeignKey("Paper", default=None) def test_foreignKey(): setupClass([Note, PersonWithNotes, Paper, EmployeeWithNotes], force=True) note = Note(text="person") PersonWithNotes(firstName='Oneof', lastName='Authors', note=note) note = Note(text="employee") EmployeeWithNotes(firstName='Project', lastName='Leader', note=note) paper = Paper(content="secret") EmployeeWithNotes(firstName='Senior', lastName='Clerk', paper=paper) PersonWithNotes(firstName='Some', lastName='Person') person = PersonWithNotes.get(1) assert isinstance(person, PersonWithNotes) and \ not isinstance(person, EmployeeWithNotes) assert person.note.text == "person" employee = EmployeeWithNotes.get(2) assert isinstance(employee, EmployeeWithNotes) assert employee.note.text == "employee" save_employee = employee # comparison to None needed to build the right SQL expression persons = PersonWithNotes.select(PersonWithNotes.q.noteID != None) # noqa assert persons.count() == 2 persons = PersonWithNotes.selectBy(noteID=person.note.id) assert persons.count() == 1 # comparison to None needed to build the right SQL expression employee = EmployeeWithNotes.select( PersonWithNotes.q.noteID != None) # noqa assert employee.count() == 1 persons = PersonWithNotes.selectBy(noteID=person.note.id) assert persons.count() == 1 persons = PersonWithNotes.selectBy(note=person.note) assert persons.count() == 1 persons = PersonWithNotes.selectBy(note=None) assert persons.count() == 2 employee = EmployeeWithNotes.selectBy(paperID=None) assert employee.count() == 1 employee = EmployeeWithNotes.selectBy(paper=None) assert employee.count() == 1 employee = EmployeeWithNotes.selectBy(note=save_employee.note, paper=save_employee.paper) assert employee.count() == 1 employee = EmployeeWithNotes.selectBy() assert employee.count() == 2 class TestInheritableBase(InheritableSQLObject): pass class TestInheritableForeignKey(TestInheritableBase): base = ForeignKey("TestInheritableBase") def test_foreignKey2(): setupClass([TestInheritableBase, TestInheritableForeignKey]) test = TestInheritableBase() TestInheritableForeignKey(base=test) SQLObject-3.1.0/sqlobject/inheritance/tests/test_inheritance_tree.py0000644000175000017500000000210512747416060025220 0ustar phdphd00000000000000from sqlobject import StringCol from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import setupClass ######################################## # Inheritance Tree ######################################## class Tree1(InheritableSQLObject): aprop = StringCol(length=10) class Tree2(Tree1): bprop = StringCol(length=10) class Tree3(Tree1): cprop = StringCol(length=10) class Tree4(Tree2): dprop = StringCol(length=10) class Tree5(Tree2): eprop = StringCol(length=10) def test_tree(): setupClass([Tree1, Tree2, Tree3, Tree4, Tree5]) Tree1(aprop='t1') # t1 t2 = Tree2(aprop='t2', bprop='t2') Tree3(aprop='t3', cprop='t3') # t3 t4 = Tree4(aprop='t4', bprop='t4', dprop='t4') t5 = Tree5(aprop='t5', bprop='t5', eprop='t5') # find just the t5 out of childs from Tree2 assert t5 == Tree1.select(Tree2.q.childName == 'Tree5')[0] # t2,t4,t5 are all subclasses of Tree1 with t1 childName of 'Tree2' assert list(Tree1.select( Tree1.q.childName == 'Tree2', orderBy="aprop")) == [t2, t4, t5] SQLObject-3.1.0/sqlobject/inheritance/tests/test_indexes.py0000644000175000017500000000332312747416060023352 0ustar phdphd00000000000000from sqlobject import DatabaseIndex, IntCol, StringCol from sqlobject.tests.dbtest import setupClass from sqlobject.inheritance import InheritableSQLObject class InheritedPersonIndexGet(InheritableSQLObject): first_name = StringCol(notNone=True, length=100) last_name = StringCol(notNone=True, length=100) age = IntCol() pk = DatabaseIndex(first_name, last_name, unique=True) class InheritedEmployeeIndexGet(InheritedPersonIndexGet): security_number = IntCol() experience = IntCol() sec_index = DatabaseIndex(security_number, unique=True) class InheritedSalesManIndexGet(InheritedEmployeeIndexGet): _inheritable = False skill = IntCol() def test_index_get_1(): setupClass([InheritedPersonIndexGet, InheritedEmployeeIndexGet, InheritedSalesManIndexGet]) InheritedSalesManIndexGet(first_name='Michael', last_name='Pallin', age=65, security_number=2304, experience=2, skill=10) InheritedEmployeeIndexGet(first_name='Eric', last_name='Idle', age=63, security_number=3402, experience=9) InheritedPersonIndexGet(first_name='Terry', last_name='Guilliam', age=64) InheritedPersonIndexGet.pk.get('Michael', 'Pallin') InheritedEmployeeIndexGet.pk.get('Michael', 'Pallin') InheritedSalesManIndexGet.pk.get('Michael', 'Pallin') InheritedPersonIndexGet.pk.get('Eric', 'Idle') InheritedEmployeeIndexGet.pk.get('Eric', 'Idle') InheritedPersonIndexGet.pk.get(first_name='Terry', last_name='Guilliam') InheritedEmployeeIndexGet.sec_index.get(2304) InheritedEmployeeIndexGet.sec_index.get(3402) InheritedSalesManIndexGet.sec_index.get(2304) InheritedSalesManIndexGet.sec_index.get(3402) SQLObject-3.1.0/sqlobject/inheritance/tests/test_asdict.py0000644000175000017500000000321112747416060023156 0ustar phdphd00000000000000from sqlobject import StringCol from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import setupClass ######################################## # sqlmeta.asDict ######################################## class InheritablePersonAD(InheritableSQLObject): firstName = StringCol() lastName = StringCol(alternateID=True, length=255) class ManagerAD(InheritablePersonAD): department = StringCol() class EmployeeAD(InheritablePersonAD): _inheritable = False position = StringCol() def test_getColumns(): setupClass([InheritablePersonAD, ManagerAD, EmployeeAD]) for klass, columns in ( (InheritablePersonAD, ['firstName', 'lastName']), (ManagerAD, ['department', 'firstName', 'lastName']), (EmployeeAD, ['firstName', 'lastName', 'position'])): _columns = sorted(klass.sqlmeta.getColumns().keys()) assert _columns == columns def test_asDict(): setupClass([InheritablePersonAD, ManagerAD, EmployeeAD], force=True) InheritablePersonAD(firstName='Oneof', lastName='Authors') ManagerAD(firstName='ManagerAD', lastName='The', department='Dep') EmployeeAD(firstName='Project', lastName='Leader', position='Project leader') assert InheritablePersonAD.get(1).sqlmeta.asDict() == \ dict(firstName='Oneof', lastName='Authors', id=1) assert InheritablePersonAD.get(2).sqlmeta.asDict() == \ dict(firstName='ManagerAD', lastName='The', department='Dep', id=2) assert InheritablePersonAD.get(3).sqlmeta.asDict() == \ dict(firstName='Project', lastName='Leader', position='Project leader', id=3) SQLObject-3.1.0/sqlobject/inheritance/tests/testDestroyCascade.py0000644000175000017500000000102312747416060024444 0ustar phdphd00000000000000from sqlobject import ForeignKey, IntCol, SQLObject from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import setupClass class TestCascade1(InheritableSQLObject): dummy = IntCol() class TestCascade2(TestCascade1): c = ForeignKey('TestCascade3', cascade='null') class TestCascade3(SQLObject): dummy = IntCol() def test_destroySelf(): setupClass([TestCascade1, TestCascade3, TestCascade2]) c = TestCascade3(dummy=1) TestCascade2(cID=c.id, dummy=1) c.destroySelf() SQLObject-3.1.0/sqlobject/inheritance/iteration.py0000644000175000017500000001015312467733425021515 0ustar phdphd00000000000000from sqlobject import sqlbuilder from sqlobject.classregistry import findClass from sqlobject.dbconnection import Iteration class InheritableIteration(Iteration): # Default array size for cursor.fetchmany() defaultArraySize = 10000 def __init__(self, dbconn, rawconn, select, keepConnection=False): super(InheritableIteration, self).__init__(dbconn, rawconn, select, keepConnection) self.lazyColumns = select.ops.get('lazyColumns', False) self.cursor.arraysize = self.defaultArraySize self._results = [] # Find the index of the childName column childNameIdx = None columns = select.sourceClass.sqlmeta.columnList for i, column in enumerate(columns): if column.name == "childName": childNameIdx = i break self._childNameIdx = childNameIdx def next(self): if not self._results: self._results = list(self.cursor.fetchmany()) if not self.lazyColumns: self.fetchChildren() if not self._results: self._cleanup() raise StopIteration result = self._results[0] del self._results[0] if self.lazyColumns: obj = self.select.sourceClass.get(result[0], connection=self.dbconn) return obj else: id = result[0] if id in self._childrenResults: childResults = self._childrenResults[id] del self._childrenResults[id] else: childResults = None obj = self.select.sourceClass.get( id, selectResults=result[1:], childResults=childResults, connection=self.dbconn) return obj def fetchChildren(self): """Prefetch childrens' data Fetch childrens' data for every subclass in one big .select() to avoid .get() fetching it one by one. """ self._childrenResults = {} if self._childNameIdx is None: return childIdsNames = {} childNameIdx = self._childNameIdx for result in self._results: childName = result[childNameIdx + 1] if childName: ids = childIdsNames.get(childName) if ids is None: ids = childIdsNames[childName] = [] ids.append(result[0]) dbconn = self.dbconn rawconn = self.rawconn cursor = rawconn.cursor() registry = self.select.sourceClass.sqlmeta.registry for childName, ids in childIdsNames.items(): klass = findClass(childName, registry) if len(ids) == 1: select = klass.select(klass.q.id == ids[0], childUpdate=True, connection=dbconn) else: select = klass.select(sqlbuilder.IN(klass.q.id, ids), childUpdate=True, connection=dbconn) query = dbconn.queryForSelect(select) if dbconn.debug: dbconn.printDebug(rawconn, query, 'Select children of the class %s' % childName) self.dbconn._executeRetry(rawconn, cursor, query) for result in cursor.fetchall(): # Inheritance child classes may have no own columns # (that makes sense when child class has a join # that does not apply to parent class objects). # In such cases result[1:] gives an empty tuple # which is interpreted as "no results fetched" in .get(). # So .get() issues another query which is absolutely # meaningless (like "SELECT NULL FROM child WHERE id=1"). # In order to avoid this, we replace empty results # with non-empty tuple. Extra values in selectResults # are Ok - they will be ignored by ._SO_selectInit(). self._childrenResults[result[0]] = result[1:] or (None,) SQLObject-3.1.0/sqlobject/main.py0000644000175000017500000021044112752476767016166 0ustar phdphd00000000000000""" SQLObject --------- :author: Ian Bicking SQLObject is a object-relational mapper. See SQLObject.html or SQLObject.rst for more. With the help by Oleg Broytman and many other contributors. See Authors.rst. This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. """ import sys import threading import weakref import types import warnings from . import sqlbuilder from . import dbconnection from . import col from . import styles from . import joins from . import index from . import classregistry from . import declarative from . import events from .sresults import SelectResults from .util.threadinglocal import local from sqlobject.compat import PY2, with_metaclass, string_type, unicode_type if ((sys.version_info[0] == 2) and (sys.version_info[:2] < (2, 6))) or \ ((sys.version_info[0] == 3) and (sys.version_info[:2] < (3, 4))): raise ImportError("SQLObject requires Python 2.6, 2.7 or 3.4+") if not PY2: # alias for python 3 compatability long = int """ This thread-local storage is needed for RowCreatedSignals. It gathers code-blocks to execute _after_ the whole hierachy of inherited SQLObjects is created. See SQLObject._create """ NoDefault = sqlbuilder.NoDefault class SQLObjectNotFound(LookupError): pass class SQLObjectIntegrityError(Exception): pass def makeProperties(obj): """ This function takes a dictionary of methods and finds methods named like: * _get_attr * _set_attr * _del_attr * _doc_attr Except for _doc_attr, these should be methods. It then creates properties from these methods, like property(_get_attr, _set_attr, _del_attr, _doc_attr). Missing methods are okay. """ if isinstance(obj, dict): def setFunc(var, value): obj[var] = value d = obj else: def setFunc(var, value): setattr(obj, var, value) d = obj.__dict__ props = {} for var, value in d.items(): if var.startswith('_set_'): props.setdefault(var[5:], {})['set'] = value elif var.startswith('_get_'): props.setdefault(var[5:], {})['get'] = value elif var.startswith('_del_'): props.setdefault(var[5:], {})['del'] = value elif var.startswith('_doc_'): props.setdefault(var[5:], {})['doc'] = value for var, setters in props.items(): if len(setters) == 1 and 'doc' in setters: continue if var in d: if isinstance(d[var], (types.MethodType, types.FunctionType)): warnings.warn( "I tried to set the property %r, but it was " "already set, as a method (%r). Methods have " "significantly different semantics than properties, " "and this may be a sign of a bug in your code." % (var, d[var])) continue setFunc(var, property(setters.get('get'), setters.get('set'), setters.get('del'), setters.get('doc'))) def unmakeProperties(obj): if isinstance(obj, dict): def delFunc(obj, var): del obj[var] d = obj else: delFunc = delattr d = obj.__dict__ for var, value in list(d.items()): if isinstance(value, property): for prop in [value.fget, value.fset, value.fdel]: if prop and prop.__name__ not in d: delFunc(obj, var) break def findDependencies(name, registry=None): depends = [] for klass in classregistry.registry(registry).allClasses(): if findDependantColumns(name, klass): depends.append(klass) else: for join in klass.sqlmeta.joins: if isinstance(join, joins.SORelatedJoin) and \ join.otherClassName == name: depends.append(klass) break return depends def findDependantColumns(name, klass): depends = [] for _col in klass.sqlmeta.columnList: if _col.foreignKey == name and _col.cascade is not None: depends.append(_col) return depends def _collectAttributes(cls, new_attrs, look_for_class): """Finds all attributes in `new_attrs` that are instances of `look_for_class`. The ``.name`` attribute is set for any matching objects. Returns them as a list. """ result = [] for attr, value in new_attrs.items(): if isinstance(value, look_for_class): value.name = attr delattr(cls, attr) result.append(value) return result class CreateNewSQLObject: """ Dummy singleton to use in place of an ID, to signal we want a new object. """ pass class sqlmeta(with_metaclass(declarative.DeclarativeMeta, object)): """ This object is the object we use to keep track of all sorts of information. Subclasses are made for each SQLObject subclass (dynamically if necessary), and instances are created to go alongside every SQLObject instance. """ table = None idName = None idSequence = None # This function is used to coerce IDs into the proper format, # so you should replace it with str, or another function, if you # aren't using integer IDs idType = int style = None lazyUpdate = False defaultOrder = None cacheValues = True registry = None fromDatabase = False # Default is false, but we set it to true for the *instance* # when necessary: (bad clever? maybe) expired = False # This is a mapping from column names to SOCol (or subclass) # instances: columns = {} columnList = [] # This is a mapping from column names to Col (or subclass) # instances; these objects don't have the logic that the SOCol # objects do, and are not attached to this class closely. columnDefinitions = {} # These are lists of the join and index objects: indexes = [] indexDefinitions = [] joins = [] joinDefinitions = [] # These attributes shouldn't be shared with superclasses: _unshared_attributes = ['table', 'columns', 'childName'] # These are internal bookkeeping attributes; the class-level # definition is a default for the instances, instances will # reset these values. # When an object is being created, it has an instance # variable _creating, which is true. This way all the # setters can be captured until the object is complete, # and then the row is inserted into the database. Once # that happens, _creating is deleted from the instance, # and only the class variable (which is always false) is # left. _creating = False _obsolete = False # Sometimes an intance is attached to a connection, not # globally available. In that case, self.sqlmeta._perConnection # will be true. It's false by default: _perConnection = False # Inheritance definitions: parentClass = None # A reference to the parent class childClasses = {} # References to child classes, keyed by childName childName = None # Class name for inheritance child object creation # Does the row require syncing? dirty = False # Default encoding for UnicodeCol's dbEncoding = None def __classinit__(cls, new_attrs): for attr in cls._unshared_attributes: if attr not in new_attrs: setattr(cls, attr, None) declarative.setup_attributes(cls, new_attrs) def __init__(self, instance): self.instance = weakref.proxy(instance) @classmethod def send(cls, signal, *args, **kw): events.send(signal, cls.soClass, *args, **kw) @classmethod def setClass(cls, soClass): cls.soClass = soClass if not cls.style: cls.style = styles.defaultStyle try: if cls.soClass._connection and cls.soClass._connection.style: cls.style = cls.soClass._connection.style except AttributeError: pass if cls.table is None: cls.table = cls.style.pythonClassToDBTable(cls.soClass.__name__) if cls.idName is None: cls.idName = cls.style.idForTable(cls.table) # plainSetters are columns that haven't been overridden by the # user, so we can contact the database directly to set them. # Note that these can't set these in the SQLObject class # itself, because they specific to this subclass of SQLObject, # and cannot be shared among classes. cls._plainSetters = {} cls._plainGetters = {} cls._plainForeignSetters = {} cls._plainForeignGetters = {} cls._plainJoinGetters = {} cls._plainJoinAdders = {} cls._plainJoinRemovers = {} # This is a dictionary of columnName: columnObject # None of these objects can be shared with superclasses cls.columns = {} cls.columnList = [] # These, however, can be shared: cls.columnDefinitions = cls.columnDefinitions.copy() cls.indexes = [] cls.indexDefinitions = cls.indexDefinitions[:] cls.joins = [] cls.joinDefinitions = cls.joinDefinitions[:] ############################################################ # Adding special values, like columns and indexes ############################################################ ######################################## # Column handling ######################################## @classmethod def addColumn(cls, columnDef, changeSchema=False, connection=None): post_funcs = [] cls.send(events.AddColumnSignal, cls.soClass, connection, columnDef.name, columnDef, changeSchema, post_funcs) sqlmeta = cls soClass = cls.soClass del cls column = columnDef.withClass(soClass) name = column.name assert name != 'id', ( "The 'id' column is implicit, and should not be defined as " "a column") assert name not in sqlmeta.columns, ( "The class %s.%s already has a column %r (%r), you cannot " "add the column %r" % (soClass.__module__, soClass.__name__, name, sqlmeta.columnDefinitions[name], columnDef)) # Collect columns from the parent classes to test # if the column is not in a parent class parent_columns = [] for base in soClass.__bases__: if hasattr(base, "sqlmeta"): parent_columns.extend(base.sqlmeta.columns.keys()) if hasattr(soClass, name): assert (name in parent_columns) or (name == "childName"), ( "The class %s.%s already has a variable or method %r, " "you cannot add the column %r" % ( soClass.__module__, soClass.__name__, name, name)) sqlmeta.columnDefinitions[name] = columnDef sqlmeta.columns[name] = column # A stable-ordered version of the list... sqlmeta.columnList.append(column) ################################################### # Create the getter function(s). We'll start by # creating functions like _SO_get_columnName, # then if there's no function named _get_columnName # we'll alias that to _SO_get_columnName. This # allows a sort of super call, even though there's # no superclass that defines the database access. if sqlmeta.cacheValues: # We create a method here, which is just a function # that takes "self" as the first argument. getter = eval( 'lambda self: self._SO_loadValue(%s)' % repr(instanceName(name))) else: # If we aren't caching values, we just call the # function _SO_getValue, which fetches from the # database. getter = eval('lambda self: self._SO_getValue(%s)' % repr(name)) setattr(soClass, rawGetterName(name), getter) # Here if the _get_columnName method isn't in the # definition, we add it with the default # _SO_get_columnName definition. if not hasattr(soClass, getterName(name)) or (name == 'childName'): setattr(soClass, getterName(name), getter) sqlmeta._plainGetters[name] = 1 ################################################# # Create the setter function(s) # Much like creating the getters, we will create # _SO_set_columnName methods, and then alias them # to _set_columnName if the user hasn't defined # those methods themself. # @@: This is lame; immutable right now makes it unsettable, # making the table read-only if not column.immutable: # We start by just using the _SO_setValue method setter = eval( 'lambda self, val: self._SO_setValue' '(%s, val, self.%s, self.%s)' % ( repr(name), '_SO_from_python_%s' % name, '_SO_to_python_%s' % name)) setattr(soClass, '_SO_from_python_%s' % name, column.from_python) setattr(soClass, '_SO_to_python_%s' % name, column.to_python) setattr(soClass, rawSetterName(name), setter) # Then do the aliasing if not hasattr(soClass, setterName(name)) or (name == 'childName'): setattr(soClass, setterName(name), setter) # We keep track of setters that haven't been # overridden, because we can combine these # set columns into one SQL UPDATE query. sqlmeta._plainSetters[name] = 1 ################################################## # Here we check if the column is a foreign key, in # which case we need to make another method that # fetches the key and constructs the sister # SQLObject instance. if column.foreignKey: # We go through the standard _SO_get_columnName deal # we're giving the object, not the ID of the # object this time: origName = column.origName if sqlmeta.cacheValues: # self._SO_class_className is a reference # to the class in question. getter = eval( 'lambda self: self._SO_foreignKey' '(self._SO_loadValue(%r), self._SO_class_%s, %s)' % (instanceName(name), column.foreignKey, column.refColumn and repr(column.refColumn))) else: # Same non-caching version as above. getter = eval( 'lambda self: self._SO_foreignKey' '(self._SO_getValue(%s), self._SO_class_%s, %s)' % (repr(name), column.foreignKey, column.refColumn and repr(column.refColumn))) setattr(soClass, rawGetterName(origName), getter) # And we set the _get_columnName version if not hasattr(soClass, getterName(origName)): setattr(soClass, getterName(origName), getter) sqlmeta._plainForeignGetters[origName] = 1 if not column.immutable: # The setter just gets the ID of the object, # and then sets the real column. setter = eval( 'lambda self, val: ' 'setattr(self, %s, self._SO_getID(val, %s))' % (repr(name), column.refColumn and repr(column.refColumn))) setattr(soClass, rawSetterName(origName), setter) if not hasattr(soClass, setterName(origName)): setattr(soClass, setterName(origName), setter) sqlmeta._plainForeignSetters[origName] = 1 classregistry.registry(sqlmeta.registry).addClassCallback( column.foreignKey, lambda foreign, me, attr: setattr(me, attr, foreign), soClass, '_SO_class_%s' % column.foreignKey) if column.alternateMethodName: func = eval( 'lambda cls, val, connection=None: ' 'cls._SO_fetchAlternateID(%s, %s, val, connection=connection)' % (repr(column.name), repr(column.dbName))) setattr(soClass, column.alternateMethodName, classmethod(func)) if changeSchema: conn = connection or soClass._connection conn.addColumn(sqlmeta.table, column) if soClass._SO_finishedClassCreation: makeProperties(soClass) for func in post_funcs: func(soClass, column) @classmethod def addColumnsFromDatabase(sqlmeta, connection=None): soClass = sqlmeta.soClass conn = connection or soClass._connection for columnDef in conn.columnsFromSchema(sqlmeta.table, soClass): if columnDef.name not in sqlmeta.columnDefinitions: if isinstance(columnDef.name, unicode_type) and PY2: columnDef.name = columnDef.name.encode('ascii') sqlmeta.addColumn(columnDef) @classmethod def delColumn(cls, column, changeSchema=False, connection=None): sqlmeta = cls soClass = sqlmeta.soClass if isinstance(column, str): if column in sqlmeta.columns: column = sqlmeta.columns[column] elif column + 'ID' in sqlmeta.columns: column = sqlmeta.columns[column + 'ID'] else: raise ValueError('Unknown column ' + column) if isinstance(column, col.Col): for c in sqlmeta.columns.values(): if column is c.columnDef: column = c break else: raise IndexError( "Column with definition %r not found" % column) post_funcs = [] cls.send(events.DeleteColumnSignal, cls.soClass, connection, column.name, column, post_funcs) name = column.name del sqlmeta.columns[name] del sqlmeta.columnDefinitions[name] sqlmeta.columnList.remove(column) delattr(soClass, rawGetterName(name)) if name in sqlmeta._plainGetters: delattr(soClass, getterName(name)) delattr(soClass, rawSetterName(name)) if name in sqlmeta._plainSetters: delattr(soClass, setterName(name)) if column.foreignKey: delattr(soClass, rawGetterName(soClass.sqlmeta.style. instanceIDAttrToAttr(name))) if name in sqlmeta._plainForeignGetters: delattr(soClass, getterName(name)) delattr(soClass, rawSetterName(soClass.sqlmeta.style. instanceIDAttrToAttr(name))) if name in sqlmeta._plainForeignSetters: delattr(soClass, setterName(name)) if column.alternateMethodName: delattr(soClass, column.alternateMethodName) if changeSchema: conn = connection or soClass._connection conn.delColumn(sqlmeta, column) if soClass._SO_finishedClassCreation: unmakeProperties(soClass) makeProperties(soClass) for func in post_funcs: func(soClass, column) ######################################## # Join handling ######################################## @classmethod def addJoin(cls, joinDef): sqlmeta = cls soClass = cls.soClass # The name of the method we'll create. If it's # automatically generated, it's generated by the # join class. join = joinDef.withClass(soClass) meth = join.joinMethodName sqlmeta.joins.append(join) index = len(sqlmeta.joins) - 1 if joinDef not in sqlmeta.joinDefinitions: sqlmeta.joinDefinitions.append(joinDef) # The function fetches the join by index, and # then lets the join object do the rest of the # work: func = eval( 'lambda self: self.sqlmeta.joins[%i].performJoin(self)' % index) # And we do the standard _SO_get_... _get_... deal setattr(soClass, rawGetterName(meth), func) if not hasattr(soClass, getterName(meth)): setattr(soClass, getterName(meth), func) sqlmeta._plainJoinGetters[meth] = 1 # Some joins allow you to remove objects from the # join. if hasattr(join, 'remove'): # Again, we let it do the remove, and we do the # standard naming trick. func = eval( 'lambda self, obj: self.sqlmeta.joins[%i].remove(self, obj)' % index) setattr(soClass, '_SO_remove' + join.addRemoveName, func) if not hasattr(soClass, 'remove' + join.addRemoveName): setattr(soClass, 'remove' + join.addRemoveName, func) sqlmeta._plainJoinRemovers[meth] = 1 # Some joins allow you to add objects. if hasattr(join, 'add'): # And again... func = eval( 'lambda self, obj: self.sqlmeta.joins[%i].add(self, obj)' % index) setattr(soClass, '_SO_add' + join.addRemoveName, func) if not hasattr(soClass, 'add' + join.addRemoveName): setattr(soClass, 'add' + join.addRemoveName, func) sqlmeta._plainJoinAdders[meth] = 1 if soClass._SO_finishedClassCreation: makeProperties(soClass) @classmethod def delJoin(sqlmeta, joinDef): soClass = sqlmeta.soClass for join in sqlmeta.joins: # previously deleted joins will be None, so it must # be skipped or it'll error out on the next line. if join is None: continue if joinDef is join.joinDef: break else: raise IndexError( "Join %r not found in class %r (from %r)" % (joinDef, soClass, sqlmeta.joins)) meth = join.joinMethodName sqlmeta.joinDefinitions.remove(joinDef) for i in range(len(sqlmeta.joins)): if sqlmeta.joins[i] is join: # Have to leave None, because we refer to joins # by index. sqlmeta.joins[i] = None delattr(soClass, rawGetterName(meth)) if meth in sqlmeta._plainJoinGetters: delattr(soClass, getterName(meth)) if hasattr(join, 'remove'): delattr(soClass, '_SO_remove' + join.addRemovePrefix) if meth in sqlmeta._plainJoinRemovers: delattr(soClass, 'remove' + join.addRemovePrefix) if hasattr(join, 'add'): delattr(soClass, '_SO_add' + join.addRemovePrefix) if meth in sqlmeta._plainJoinAdders: delattr(soClass, 'add' + join.addRemovePrefix) if soClass._SO_finishedClassCreation: unmakeProperties(soClass) makeProperties(soClass) ######################################## # Indexes ######################################## @classmethod def addIndex(cls, indexDef): cls.indexDefinitions.append(indexDef) index = indexDef.withClass(cls.soClass) cls.indexes.append(index) setattr(cls.soClass, index.name, index) ######################################## # Utility methods ######################################## @classmethod def getColumns(sqlmeta): return sqlmeta.columns.copy() def asDict(self): """ Return the object as a dictionary of columns to values. """ result = {} for key in self.getColumns(): result[key] = getattr(self.instance, key) result['id'] = self.instance.id return result @classmethod def expireAll(sqlmeta, connection=None): """ Expire all instances of this class. """ soClass = sqlmeta.soClass connection = connection or soClass._connection cache_set = connection.cache cache_set.weakrefAll(soClass) for item in cache_set.getAll(soClass): item.expire() sqlhub = dbconnection.ConnectionHub() # Turning it on gives earlier warning about things # that will be deprecated (having this off we won't flood people # with warnings right away). warnings_level = 1 exception_level = None # Current levels: # 1) Actively deprecated # 2) Deprecated after 1 # 3) Deprecated after 2 def deprecated(message, level=1, stacklevel=2): if exception_level is not None and exception_level <= level: raise NotImplementedError(message) if warnings_level is not None and warnings_level <= level: warnings.warn(message, DeprecationWarning, stacklevel=stacklevel) # if sys.version_info[:2] < (2, 6): # deprecated("Support for Python 2.5 has been declared obsolete " # "and will be removed in the next release of SQLObject") def setDeprecationLevel(warning=1, exception=None): """ Set the deprecation level for SQLObject. Low levels are more actively being deprecated. Any warning at a level at or below ``warning`` will give a warning. Any warning at a level at or below ``exception`` will give an exception. You can use a higher ``exception`` level for tests to help upgrade your code. ``None`` for either value means never warn or raise exceptions. The levels currently mean: 1) Deprecated in current version. Will be removed in next version. 2) Planned to deprecate in next version, remove later. 3) Planned to deprecate sometime, remove sometime much later. As the SQLObject versions progress, the deprecation level of specific features will go down, indicating the advancing nature of the feature's doom. We'll try to keep features at 1 for a major revision. As time continues there may be a level 0, which will give a useful error message (better than ``AttributeError``) but where the feature has been fully removed. """ global warnings_level, exception_level warnings_level = warning exception_level = exception class _sqlmeta_attr(object): def __init__(self, name, deprecation_level): self.name = name self.deprecation_level = deprecation_level def __get__(self, obj, type=None): if self.deprecation_level is not None: deprecated( 'Use of this attribute should be replaced with ' '.sqlmeta.%s' % self.name, level=self.deprecation_level) return getattr((type or obj).sqlmeta, self.name) _postponed_local = local() # SQLObject is the superclass for all SQLObject classes, of # course. All the deeper magic is done in MetaSQLObject, and # only lesser magic is done here. All the actual work is done # here, though -- just automatic method generation (like # methods and properties for each column) is done in # MetaSQLObject. class SQLObject(with_metaclass(declarative.DeclarativeMeta, object)): _connection = sqlhub sqlmeta = sqlmeta # DSM: The _inheritable attribute controls wheter the class can by # DSM: inherited 'logically' with a foreignKey and a back reference. _inheritable = False # Is this class inheritable? _parent = None # A reference to the parent instance childName = None # Children name (to be able to get a subclass) # The law of Demeter: the class should not call another classes by name SelectResultsClass = SelectResults def __classinit__(cls, new_attrs): # This is true if we're initializing the SQLObject class, # instead of a subclass: is_base = cls.__bases__ == (object,) cls._SO_setupSqlmeta(new_attrs, is_base) implicitColumns = _collectAttributes(cls, new_attrs, col.Col) implicitJoins = _collectAttributes(cls, new_attrs, joins.Join) implicitIndexes = _collectAttributes(cls, new_attrs, index.DatabaseIndex) if not is_base: cls._SO_cleanDeprecatedAttrs(new_attrs) if '_connection' in new_attrs: connection = new_attrs['_connection'] del cls._connection assert 'connection' not in new_attrs elif 'connection' in new_attrs: connection = new_attrs['connection'] del cls.connection else: connection = None cls._SO_finishedClassCreation = False ###################################################### # Set some attributes to their defaults, if necessary. # First we get the connection: if not connection and not getattr(cls, '_connection', None): mod = sys.modules[cls.__module__] # See if there's a __connection__ global in # the module, use it if there is. if hasattr(mod, '__connection__'): connection = mod.__connection__ # Do not check hasattr(cls, '_connection') here - it is possible # SQLObject parent class has a connection attribute that came # from sqlhub, e.g.; check __dict__ only. if connection and ('_connection' not in cls.__dict__): cls.setConnection(connection) sqlmeta = cls.sqlmeta # We have to check if there are columns in the inherited # _columns where the attribute has been set to None in this # class. If so, then we need to remove that column from # _columns. for key in sqlmeta.columnDefinitions.keys(): if (key in new_attrs and new_attrs[key] is None): del sqlmeta.columnDefinitions[key] for column in sqlmeta.columnDefinitions.values(): sqlmeta.addColumn(column) for column in implicitColumns: sqlmeta.addColumn(column) # Now the class is in an essentially OK-state, so we can # set up any magic attributes: declarative.setup_attributes(cls, new_attrs) if sqlmeta.fromDatabase: sqlmeta.addColumnsFromDatabase() for j in implicitJoins: sqlmeta.addJoin(j) for i in implicitIndexes: sqlmeta.addIndex(i) def order_getter(o): return o.creationOrder sqlmeta.columnList.sort(key=order_getter) sqlmeta.indexes.sort(key=order_getter) sqlmeta.indexDefinitions.sort(key=order_getter) # Joins cannot be sorted because addJoin created accessors # that remember indexes. # sqlmeta.joins.sort(key=order_getter) sqlmeta.joinDefinitions.sort(key=order_getter) # We don't setup the properties until we're finished with the # batch adding of all the columns... cls._notifyFinishClassCreation() cls._SO_finishedClassCreation = True makeProperties(cls) # We use the magic "q" attribute for accessing lazy # SQL where-clause generation. See the sql module for # more. if not is_base: cls.q = sqlbuilder.SQLObjectTable(cls) cls.j = sqlbuilder.SQLObjectTableWithJoins(cls) classregistry.registry(sqlmeta.registry).addClass(cls) @classmethod def _SO_setupSqlmeta(cls, new_attrs, is_base): """ This fixes up the sqlmeta attribute. It handles both the case where no sqlmeta was given (in which we need to create another subclass), or the sqlmeta given doesn't have the proper inheritance. Lastly it calls sqlmeta.setClass, which handles much of the setup. """ if ('sqlmeta' not in new_attrs and not is_base): # We have to create our own subclass, usually. # type(className, bases_tuple, attr_dict) creates a new subclass. cls.sqlmeta = type('sqlmeta', (cls.sqlmeta,), {}) if not issubclass(cls.sqlmeta, sqlmeta): # We allow no superclass and an object superclass, instead # of inheriting from sqlmeta; but in that case we replace # the class and just move over its attributes: assert cls.sqlmeta.__bases__ in ((), (object,)), ( "If you do not inherit your sqlmeta class from " "sqlobject.sqlmeta, it must not inherit from any other " "class (your sqlmeta inherits from: %s)" % cls.sqlmeta.__bases__) for base in cls.__bases__: superclass = getattr(base, 'sqlmeta', None) if superclass: break else: assert 0, ( "No sqlmeta class could be found in any superclass " "(while fixing up sqlmeta %r inheritance)" % cls.sqlmeta) values = dict(cls.sqlmeta.__dict__) for key in list(values.keys()): if key.startswith('__') and key.endswith('__'): # Magic values shouldn't be passed through: del values[key] cls.sqlmeta = type('sqlmeta', (superclass,), values) if not is_base: # Do not pollute the base sqlmeta class cls.sqlmeta.setClass(cls) @classmethod def _SO_cleanDeprecatedAttrs(cls, new_attrs): """ This removes attributes on SQLObject subclasses that have been deprecated; they are moved to the sqlmeta class, and a deprecation warning is given. """ for attr in (): if attr in new_attrs: deprecated("%r is deprecated and read-only; please do " "not use it in your classes until it is fully " "deprecated" % attr, level=1, stacklevel=5) @classmethod def get(cls, id, connection=None, selectResults=None): assert id is not None, \ 'None is not a possible id for %s' % cls.__name__ id = cls.sqlmeta.idType(id) if connection is None: cache = cls._connection.cache else: cache = connection.cache # This whole sequence comes from Cache.CacheFactory's # behavior, where a None returned means a cache miss. val = cache.get(id, cls) if val is None: try: val = cls(_SO_fetch_no_create=1) val._SO_validatorState = sqlbuilder.SQLObjectState(val) val._init(id, connection, selectResults) cache.put(id, cls, val) finally: cache.finishPut(cls) elif selectResults and not val.sqlmeta.dirty: val._SO_writeLock.acquire() try: val._SO_selectInit(selectResults) val.sqlmeta.expired = False finally: val._SO_writeLock.release() return val @classmethod def _notifyFinishClassCreation(cls): pass def _init(self, id, connection=None, selectResults=None): assert id is not None # This function gets called only when the object is # created, unlike __init__ which would be called # anytime the object was returned from cache. self.id = id self._SO_writeLock = threading.Lock() # If no connection was given, we'll inherit the class # instance variable which should have a _connection # attribute. if (connection is not None) and \ (getattr(self, '_connection', None) is not connection): self._connection = connection # Sometimes we need to know if this instance is # global or tied to a particular connection. # This flag tells us that: self.sqlmeta._perConnection = True if not selectResults: dbNames = [col.dbName for col in self.sqlmeta.columnList] selectResults = self._connection._SO_selectOne(self, dbNames) if not selectResults: raise SQLObjectNotFound( "The object %s by the ID %s does not exist" % ( self.__class__.__name__, self.id)) self._SO_selectInit(selectResults) self._SO_createValues = {} self.sqlmeta.dirty = False def _SO_loadValue(self, attrName): try: return getattr(self, attrName) except AttributeError: try: self._SO_writeLock.acquire() try: # Maybe, just in the moment since we got the lock, # some other thread did a _SO_loadValue and we # have the attribute! Let's try and find out! We # can keep trying this all day and still beat the # performance on the database call (okay, we can # keep trying this for a few msecs at least)... result = getattr(self, attrName) except AttributeError: pass else: return result self.sqlmeta.expired = False dbNames = [col.dbName for col in self.sqlmeta.columnList] selectResults = self._connection._SO_selectOne(self, dbNames) if not selectResults: raise SQLObjectNotFound( "The object %s by the ID %s has been deleted" % ( self.__class__.__name__, self.id)) self._SO_selectInit(selectResults) result = getattr(self, attrName) return result finally: self._SO_writeLock.release() def sync(self): if self.sqlmeta.lazyUpdate and self._SO_createValues: self.syncUpdate() self._SO_writeLock.acquire() try: dbNames = [col.dbName for col in self.sqlmeta.columnList] selectResults = self._connection._SO_selectOne(self, dbNames) if not selectResults: raise SQLObjectNotFound( "The object %s by the ID %s has been deleted" % ( self.__class__.__name__, self.id)) self._SO_selectInit(selectResults) self.sqlmeta.expired = False finally: self._SO_writeLock.release() def syncUpdate(self): if not self._SO_createValues: return self._SO_writeLock.acquire() try: if self.sqlmeta.columns: columns = self.sqlmeta.columns values = [(columns[v[0]].dbName, v[1]) for v in sorted( self._SO_createValues.items(), key=lambda c: columns[c[0]].creationOrder)] self._connection._SO_update(self, values) self.sqlmeta.dirty = False self._SO_createValues = {} finally: self._SO_writeLock.release() post_funcs = [] self.sqlmeta.send(events.RowUpdatedSignal, self, post_funcs) for func in post_funcs: func(self) def expire(self): if self.sqlmeta.expired: return self._SO_writeLock.acquire() try: if self.sqlmeta.expired: return for column in self.sqlmeta.columnList: delattr(self, instanceName(column.name)) self.sqlmeta.expired = True self._connection.cache.expire(self.id, self.__class__) self._SO_createValues = {} finally: self._SO_writeLock.release() def _SO_setValue(self, name, value, from_python, to_python): # This is the place where we actually update the # database. # If we are _creating, the object doesn't yet exist # in the database, and we can't insert it until all # the parts are set. So we just keep them in a # dictionary until later: d = {name: value} if not self.sqlmeta._creating and \ not getattr(self.sqlmeta, "row_update_sig_suppress", False): self.sqlmeta.send(events.RowUpdateSignal, self, d) if len(d) != 1 or name not in d: # Already called RowUpdateSignal, don't call it again # inside .set() self.sqlmeta.row_update_sig_suppress = True self.set(**d) del self.sqlmeta.row_update_sig_suppress value = d[name] if from_python: dbValue = from_python(value, self._SO_validatorState) else: dbValue = value if to_python: value = to_python(dbValue, self._SO_validatorState) if self.sqlmeta._creating or self.sqlmeta.lazyUpdate: self.sqlmeta.dirty = True self._SO_createValues[name] = dbValue setattr(self, instanceName(name), value) return self._connection._SO_update( self, [(self.sqlmeta.columns[name].dbName, dbValue)]) if self.sqlmeta.cacheValues: setattr(self, instanceName(name), value) post_funcs = [] self.sqlmeta.send(events.RowUpdatedSignal, self, post_funcs) for func in post_funcs: func(self) def set(self, _suppress_set_sig=False, **kw): if not self.sqlmeta._creating and \ not getattr(self.sqlmeta, "row_update_sig_suppress", False) \ and not _suppress_set_sig: self.sqlmeta.send(events.RowUpdateSignal, self, kw) # set() is used to update multiple values at once, # potentially with one SQL statement if possible. # Filter out items that don't map to column names. # Those will be set directly on the object using # setattr(obj, name, value). def is_column(_c): return _c in self.sqlmeta._plainSetters def f_is_column(item): return is_column(item[0]) def f_not_column(item): return not is_column(item[0]) items = kw.items() extra = dict(filter(f_not_column, items)) kw = dict(filter(f_is_column, items)) # _creating is special, see _SO_setValue if self.sqlmeta._creating or self.sqlmeta.lazyUpdate: for name, value in kw.items(): from_python = getattr(self, '_SO_from_python_%s' % name, None) if from_python: kw[name] = dbValue = from_python(value, self._SO_validatorState) else: dbValue = value to_python = getattr(self, '_SO_to_python_%s' % name, None) if to_python: value = to_python(dbValue, self._SO_validatorState) setattr(self, instanceName(name), value) self._SO_createValues.update(kw) for name, value in extra.items(): try: getattr(self.__class__, name) except AttributeError: if name not in self.sqlmeta.columns: raise TypeError( "%s.set() got an unexpected keyword argument " "%s" % (self.__class__.__name__, name)) try: setattr(self, name, value) except AttributeError as e: raise AttributeError('%s (with attribute %r)' % (e, name)) self.sqlmeta.dirty = True return self._SO_writeLock.acquire() try: # We have to go through and see if the setters are # "plain", that is, if the user has changed their # definition in any way (put in something that # normalizes the value or checks for consistency, # for instance). If so then we have to use plain # old setattr() to change the value, since we can't # read the user's mind. We'll combine everything # else into a single UPDATE, if necessary. toUpdate = {} for name, value in kw.items(): from_python = getattr(self, '_SO_from_python_%s' % name, None) if from_python: dbValue = from_python(value, self._SO_validatorState) else: dbValue = value to_python = getattr(self, '_SO_to_python_%s' % name, None) if to_python: value = to_python(dbValue, self._SO_validatorState) if self.sqlmeta.cacheValues: setattr(self, instanceName(name), value) toUpdate[name] = dbValue for name, value in extra.items(): try: getattr(self.__class__, name) except AttributeError: if name not in self.sqlmeta.columns: raise TypeError( "%s.set() got an unexpected keyword argument " "%s" % (self.__class__.__name__, name)) try: setattr(self, name, value) except AttributeError as e: raise AttributeError('%s (with attribute %r)' % (e, name)) if toUpdate: toUpdate = sorted( toUpdate.items(), key=lambda c: self.sqlmeta.columns[c[0]].creationOrder) args = [(self.sqlmeta.columns[name].dbName, value) for name, value in toUpdate] self._connection._SO_update(self, args) finally: self._SO_writeLock.release() post_funcs = [] self.sqlmeta.send(events.RowUpdatedSignal, self, post_funcs) for func in post_funcs: func(self) def _SO_selectInit(self, row): for _col, colValue in zip(self.sqlmeta.columnList, row): if _col.to_python: colValue = _col.to_python(colValue, self._SO_validatorState) setattr(self, instanceName(_col.name), colValue) def _SO_getValue(self, name): # Retrieves a single value from the database. Simple. assert not self.sqlmeta._obsolete, ( "%s with id %s has become obsolete" % (self.__class__.__name__, self.id)) # @@: do we really need this lock? # self._SO_writeLock.acquire() column = self.sqlmeta.columns[name] results = self._connection._SO_selectOne(self, [column.dbName]) # self._SO_writeLock.release() assert results is not None, "%s with id %s is not in the database" % ( self.__class__.__name__, self.id) value = results[0] if column.to_python: value = column.to_python(value, self._SO_validatorState) return value def _SO_foreignKey(self, value, joinClass, idName=None): if value is None: return None if self.sqlmeta._perConnection: connection = self._connection else: connection = None if idName is None: # Get by id return joinClass.get(value, connection=connection) return joinClass.select( getattr(joinClass.q, idName) == value, connection=connection).getOne() def __init__(self, **kw): # If we are the outmost constructor of a hiearchy of # InheritableSQLObjects (or simlpy _the_ constructor of a "normal" # SQLObject), we create a threadlocal list that collects the # RowCreatedSignals, and executes them if this very constructor is left try: _postponed_local.postponed_calls postponed_created = False except AttributeError: _postponed_local.postponed_calls = [] postponed_created = True try: # We shadow the sqlmeta class with an instance of sqlmeta # that points to us (our sqlmeta buddy object; where the # sqlmeta class is our class's buddy class) self.sqlmeta = self.__class__.sqlmeta(self) # The get() classmethod/constructor uses a magic keyword # argument when it wants an empty object, fetched from the # database. So we have nothing more to do in that case: if '_SO_fetch_no_create' in kw: return post_funcs = [] self.sqlmeta.send(events.RowCreateSignal, self, kw, post_funcs) # Pass the connection object along if we were given one. if 'connection' in kw: connection = kw.pop('connection') if getattr(self, '_connection', None) is not connection: self._connection = connection self.sqlmeta._perConnection = True self._SO_writeLock = threading.Lock() if 'id' in kw: id = self.sqlmeta.idType(kw['id']) del kw['id'] else: id = None self._create(id, **kw) for func in post_funcs: func(self) finally: # if we are the creator of the tl-storage, we # have to exectute and under all circumstances # remove the tl-storage if postponed_created: try: for func in _postponed_local.postponed_calls: func() finally: del _postponed_local.postponed_calls def _create(self, id, **kw): self.sqlmeta._creating = True self._SO_createValues = {} self._SO_validatorState = sqlbuilder.SQLObjectState(self) # First we do a little fix-up on the keywords we were # passed: for column in self.sqlmeta.columnList: # Then we check if the column wasn't passed in, and # if not we try to get the default. if column.name not in kw and column.foreignName not in kw: default = column.default # If we don't get it, it's an error: # If we specified an SQL DEFAULT, then we should use that if default is NoDefault: if column.defaultSQL is None: raise TypeError( "%s() did not get expected keyword argument " "'%s'" % (self.__class__.__name__, column.name)) else: # There is defaultSQL for the column - # do not put the column to kw # so that the backend creates the value. continue # Otherwise we put it in as though they did pass # that keyword: kw[column.name] = default self.set(**kw) # Then we finalize the process: self._SO_finishCreate(id) def _SO_finishCreate(self, id=None): # Here's where an INSERT is finalized. # These are all the column values that were supposed # to be set, but were delayed until now: setters = self._SO_createValues.items() setters = sorted( setters, key=lambda c: self.sqlmeta.columns[c[0]].creationOrder) # Here's their database names: names = [self.sqlmeta.columns[v[0]].dbName for v in setters] values = [v[1] for v in setters] # Get rid of _SO_create*, we aren't creating anymore. # Doesn't have to be threadsafe because we're still in # new(), which doesn't need to be threadsafe. self.sqlmeta.dirty = False if not self.sqlmeta.lazyUpdate: del self._SO_createValues else: self._SO_createValues = {} del self.sqlmeta._creating # Do the insert -- most of the SQL in this case is left # up to DBConnection, since getting a new ID is # non-standard. id = self._connection.queryInsertID(self, id, names, values) cache = self._connection.cache cache.created(id, self.__class__, self) self._init(id) post_funcs = [] kw = dict([('class', self.__class__), ('id', id)]) def _send_RowCreatedSignal(): self.sqlmeta.send(events.RowCreatedSignal, self, kw, post_funcs) for func in post_funcs: func(self) _postponed_local.postponed_calls.append(_send_RowCreatedSignal) def _SO_getID(self, obj, refColumn=None): return getID(obj, refColumn) @classmethod def _findAlternateID(cls, name, dbName, value, connection=None): if isinstance(name, str): name = (name,) value = (value,) if len(name) != len(value): raise ValueError( "'column' and 'value' tuples must be of the same size") new_value = [] for n, v in zip(name, value): from_python = getattr(cls, '_SO_from_python_' + n) if from_python: v = from_python( v, sqlbuilder.SQLObjectState(cls, connection=connection)) new_value.append(v) condition = sqlbuilder.AND( *[getattr(cls.q, _n) == _v for _n, _v in zip(name, new_value)]) return (connection or cls._connection)._SO_selectOneAlt( cls, [cls.sqlmeta.idName] + [column.dbName for column in cls.sqlmeta.columnList], condition), None @classmethod def _SO_fetchAlternateID(cls, name, dbName, value, connection=None, idxName=None): result, obj = cls._findAlternateID(name, dbName, value, connection) if not result: if idxName is None: raise SQLObjectNotFound( "The %s by alternateID %s = %s does not exist" % ( cls.__name__, name, repr(value))) else: names = [] for i in range(len(name)): names.append("%s = %s" % (name[i], repr(value[i]))) names = ', '.join(names) raise SQLObjectNotFound( "The %s by unique index %s(%s) does not exist" % ( cls.__name__, idxName, names)) if obj: return obj if connection: obj = cls.get(result[0], connection=connection, selectResults=result[1:]) else: obj = cls.get(result[0], selectResults=result[1:]) return obj @classmethod def _SO_depends(cls): return findDependencies(cls.__name__, cls.sqlmeta.registry) @classmethod def select(cls, clause=None, clauseTables=None, orderBy=NoDefault, limit=None, lazyColumns=False, reversed=False, distinct=False, connection=None, join=None, forUpdate=False): return cls.SelectResultsClass(cls, clause, clauseTables=clauseTables, orderBy=orderBy, limit=limit, lazyColumns=lazyColumns, reversed=reversed, distinct=distinct, connection=connection, join=join, forUpdate=forUpdate) @classmethod def selectBy(cls, connection=None, **kw): conn = connection or cls._connection return cls.SelectResultsClass(cls, conn._SO_columnClause(cls, kw), connection=conn) @classmethod def tableExists(cls, connection=None): conn = connection or cls._connection return conn.tableExists(cls.sqlmeta.table) @classmethod def dropTable(cls, ifExists=False, dropJoinTables=True, cascade=False, connection=None): conn = connection or cls._connection if ifExists and not cls.tableExists(connection=conn): return extra_sql = [] post_funcs = [] cls.sqlmeta.send(events.DropTableSignal, cls, connection, extra_sql, post_funcs) conn.dropTable(cls.sqlmeta.table, cascade) if dropJoinTables: cls.dropJoinTables(ifExists=ifExists, connection=conn) for sql in extra_sql: connection.query(sql) for func in post_funcs: func(cls, conn) @classmethod def createTable(cls, ifNotExists=False, createJoinTables=True, createIndexes=True, applyConstraints=True, connection=None): conn = connection or cls._connection if ifNotExists and cls.tableExists(connection=conn): return extra_sql = [] post_funcs = [] cls.sqlmeta.send(events.CreateTableSignal, cls, connection, extra_sql, post_funcs) constraints = conn.createTable(cls) if applyConstraints: for constraint in constraints: conn.query(constraint) else: extra_sql.extend(constraints) if createJoinTables: cls.createJoinTables(ifNotExists=ifNotExists, connection=conn) if createIndexes: cls.createIndexes(ifNotExists=ifNotExists, connection=conn) for func in post_funcs: func(cls, conn) return extra_sql @classmethod def createTableSQL(cls, createJoinTables=True, createIndexes=True, connection=None): conn = connection or cls._connection sql, constraints = conn.createTableSQL(cls) if createJoinTables: join_sql = cls.createJoinTablesSQL(connection=conn) if join_sql: sql += ';\n' + join_sql if createIndexes: index_sql = cls.createIndexesSQL(connection=conn) if index_sql: sql += ';\n' + index_sql return sql, constraints @classmethod def createJoinTables(cls, ifNotExists=False, connection=None): conn = connection or cls._connection for join in cls._getJoinsToCreate(): if (ifNotExists and conn.tableExists(join.intermediateTable)): continue conn._SO_createJoinTable(join) @classmethod def createJoinTablesSQL(cls, connection=None): conn = connection or cls._connection sql = [] for join in cls._getJoinsToCreate(): sql.append(conn._SO_createJoinTableSQL(join)) return ';\n'.join(sql) @classmethod def createIndexes(cls, ifNotExists=False, connection=None): conn = connection or cls._connection for _index in cls.sqlmeta.indexes: if not _index: continue conn._SO_createIndex(cls, _index) @classmethod def createIndexesSQL(cls, connection=None): conn = connection or cls._connection sql = [] for _index in cls.sqlmeta.indexes: if not _index: continue sql.append(conn.createIndexSQL(cls, _index)) return ';\n'.join(sql) @classmethod def _getJoinsToCreate(cls): joins = [] for join in cls.sqlmeta.joins: if not join: continue if not join.hasIntermediateTable() or \ not getattr(join, 'createRelatedTable', True): continue if join.soClass.__name__ > join.otherClass.__name__: continue joins.append(join) return joins @classmethod def dropJoinTables(cls, ifExists=False, connection=None): conn = connection or cls._connection for join in cls.sqlmeta.joins: if not join: continue if not join.hasIntermediateTable() or \ not getattr(join, 'createRelatedTable', True): continue if join.soClass.__name__ > join.otherClass.__name__: continue if ifExists and \ not conn.tableExists(join.intermediateTable): continue conn._SO_dropJoinTable(join) @classmethod def clearTable(cls, connection=None, clearJoinTables=True): # 3-03 @@: Maybe this should check the cache... but it's # kind of crude anyway, so... conn = connection or cls._connection conn.clearTable(cls.sqlmeta.table) if clearJoinTables: for join in cls._getJoinsToCreate(): conn.clearTable(join.intermediateTable) def destroySelf(self): post_funcs = [] self.sqlmeta.send(events.RowDestroySignal, self, post_funcs) # Kills this object. Kills it dead! klass = self.__class__ # Free related joins on the base class for join in klass.sqlmeta.joins: if isinstance(join, joins.SORelatedJoin): q = "DELETE FROM %s WHERE %s=%d" % (join.intermediateTable, join.joinColumn, self.id) self._connection.query(q) depends = [] depends = self._SO_depends() for k in depends: # Free related joins for join in k.sqlmeta.joins: if isinstance(join, joins.SORelatedJoin) and \ join.otherClassName == klass.__name__: q = "DELETE FROM %s WHERE %s=%d" % (join.intermediateTable, join.otherColumn, self.id) self._connection.query(q) cols = findDependantColumns(klass.__name__, k) # Don't confuse the rest of the process if len(cols) == 0: continue query = [] delete = setnull = restrict = False for _col in cols: if _col.cascade is False: # Found a restriction restrict = True query.append(getattr(k.q, _col.name) == self.id) if _col.cascade == 'null': setnull = _col.name elif _col.cascade: delete = True assert delete or setnull or restrict, ( "Class %s depends on %s accoriding to " "findDependantColumns, but this seems inaccurate" % (k, klass)) query = sqlbuilder.OR(*query) results = k.select(query, connection=self._connection) if restrict: if results.count(): # Restrictions only apply if there are # matching records on the related table raise SQLObjectIntegrityError( "Tried to delete %s::%s but " "table %s has a restriction against it" % (klass.__name__, self.id, k.__name__)) else: for row in results: if delete: row.destroySelf() else: row.set(**{setnull: None}) self.sqlmeta._obsolete = True self._connection._SO_delete(self) self._connection.cache.expire(self.id, self.__class__) for func in post_funcs: func(self) post_funcs = [] self.sqlmeta.send(events.RowDestroyedSignal, self, post_funcs) for func in post_funcs: func(self) @classmethod def delete(cls, id, connection=None): obj = cls.get(id, connection=connection) obj.destroySelf() @classmethod def deleteMany(cls, where=NoDefault, connection=None): conn = connection or cls._connection conn.query(conn.sqlrepr(sqlbuilder.Delete(cls.sqlmeta.table, where))) @classmethod def deleteBy(cls, connection=None, **kw): conn = connection or cls._connection conn.query(conn.sqlrepr(sqlbuilder.Delete( cls.sqlmeta.table, conn._SO_columnClause(cls, kw)))) def __repr__(self): if not hasattr(self, 'id'): # Object initialization not finished. No attributes can be read. return '<%s (not initialized)>' % self.__class__.__name__ return '<%s %r %s>' \ % (self.__class__.__name__, self.id, ' '.join( ['%s=%s' % (name, repr(value)) for name, value in self._reprItems()])) def __sqlrepr__(self, db): return str(self.id) @classmethod def sqlrepr(cls, value, connection=None): return (connection or cls._connection).sqlrepr(value) @classmethod def coerceID(cls, value): if isinstance(value, cls): return value.id else: return cls.sqlmeta.idType(value) def _reprItems(self): items = [] for _col in self.sqlmeta.columnList: value = getattr(self, _col.name) r = repr(value) if len(r) > 20: value = r[:17] + "..." + r[-1] items.append((_col.name, value)) return items @classmethod def setConnection(cls, value): if isinstance(value, string_type): value = dbconnection.connectionForURI(value) cls._connection = value def tablesUsedImmediate(self): return [self.__class__.q] # hash implementation def __hash__(self): # We hash on class name and id, since that should be # unique return hash((self.__class__.__name__, self.id)) # Comparison def __eq__(self, other): if self.__class__ is other.__class__: if self.id == other.id: return True return False def __ne__(self, other): return not self.__eq__(other) def __lt__(self, other): return NotImplemented def __le__(self, other): return NotImplemented def __gt__(self, other): return NotImplemented def __ge__(self, other): return NotImplemented # (De)serialization (pickle, etc.) def __getstate__(self): if self.sqlmeta._perConnection: from pickle import PicklingError raise PicklingError( 'Cannot pickle an SQLObject instance ' 'that has a per-instance connection') if self.sqlmeta.lazyUpdate and self._SO_createValues: self.syncUpdate() d = self.__dict__.copy() del d['sqlmeta'] del d['_SO_validatorState'] del d['_SO_writeLock'] del d['_SO_createValues'] return d def __setstate__(self, d): self.__init__(_SO_fetch_no_create=1) self._SO_validatorState = sqlbuilder.SQLObjectState(self) self._SO_writeLock = threading.Lock() self._SO_createValues = {} self.__dict__.update(d) cls = self.__class__ cache = self._connection.cache if cache.tryGet(self.id, cls) is not None: raise ValueError( "Cannot unpickle %s row with id=%s - " "a different instance with the id already exists " "in the cache" % (cls.__name__, self.id)) cache.created(self.id, cls, self) def setterName(name): return '_set_%s' % name def rawSetterName(name): return '_SO_set_%s' % name def getterName(name): return '_get_%s' % name def rawGetterName(name): return '_SO_get_%s' % name def instanceName(name): return '_SO_val_%s' % name ######################################## # Utility functions (for external consumption) ######################################## def getID(obj, refColumn=None): if isinstance(obj, SQLObject): return getattr(obj, refColumn or 'id') elif isinstance(obj, int): return obj elif isinstance(obj, long): return int(obj) elif isinstance(obj, str): try: return int(obj) except ValueError: return obj elif obj is None: return None def getObject(obj, klass): if isinstance(obj, int): return klass(obj) elif isinstance(obj, long): return klass(int(obj)) elif isinstance(obj, str): return klass(int(obj)) elif obj is None: return None else: return obj __all__ = [ 'NoDefault', 'SQLObject', 'SQLObjectIntegrityError', 'SQLObjectNotFound', 'getID', 'getObject', 'sqlhub', 'sqlmeta', ] SQLObject-3.1.0/sqlobject/.coveragerc0000644000175000017500000000030112753115111016747 0ustar phdphd00000000000000[run] omit = firebird/*.py maxdb/*.py mssql/*.py rdbhost/*.py sybase/*.py tests/test_boundattributes.py tests/test_paste.py util/threadinglocal.py wsgi_middleware.py SQLObject-3.1.0/sqlobject/boundattributes.py0000644000175000017500000001013712470110264020426 0ustar phdphd00000000000000""" Bound attributes are attributes that are bound to a specific class and a specific name. In SQLObject a typical example is a column object, which knows its name and class. A bound attribute should define a method ``__addtoclass__(added_class, name)`` (attributes without this method will simply be treated as normal). The return value is ignored; if the attribute wishes to change the value in the class, it must call ``setattr(added_class, name, new_value)``. BoundAttribute is a class that facilitates lazy attribute creation. """ from __future__ import absolute_import from . import declarative from . import events __all__ = ['BoundAttribute', 'BoundFactory'] class BoundAttribute(declarative.Declarative): """ This is a declarative class that passes all the values given to it to another object. So you can pass it arguments (via __init__/__call__) or give it the equivalent of keyword arguments through subclassing. Then a bound object will be added in its place. To hook this other object in, override ``make_object(added_class, name, **attrs)`` and maybe ``set_object(added_class, name, **attrs)`` (the default implementation of ``set_object`` just resets the attribute to whatever ``make_object`` returned). Also see ``BoundFactory``. """ _private_variables = ( '_private_variables', '_all_attributes', '__classinit__', '__addtoclass__', '_add_attrs', 'set_object', 'make_object', 'clone_in_subclass', ) _all_attrs = () clone_for_subclass = True def __classinit__(cls, new_attrs): declarative.Declarative.__classinit__(cls, new_attrs) cls._all_attrs = cls._add_attrs(cls, new_attrs) def __instanceinit__(self, new_attrs): declarative.Declarative.__instanceinit__(self, new_attrs) self.__dict__['_all_attrs'] = self._add_attrs(self, new_attrs) @staticmethod def _add_attrs(this_object, new_attrs): private = this_object._private_variables all_attrs = list(this_object._all_attrs) for key in new_attrs.keys(): if key.startswith('_') or key in private: continue if key not in all_attrs: all_attrs.append(key) return tuple(all_attrs) @declarative.classinstancemethod def __addtoclass__(self, cls, added_class, attr_name): me = self or cls attrs = {} for name in me._all_attrs: attrs[name] = getattr(me, name) attrs['added_class'] = added_class attrs['attr_name'] = attr_name obj = me.make_object(**attrs) if self.clone_for_subclass: def on_rebind(new_class_name, bases, new_attrs, post_funcs, early_funcs): def rebind(new_class): me.set_object( new_class, attr_name, me.make_object(**attrs)) post_funcs.append(rebind) events.listen(receiver=on_rebind, soClass=added_class, signal=events.ClassCreateSignal, weak=False) me.set_object(added_class, attr_name, obj) @classmethod def set_object(cls, added_class, attr_name, obj): setattr(added_class, attr_name, obj) @classmethod def make_object(cls, added_class, attr_name, *args, **attrs): raise NotImplementedError def __setattr__(self, name, value): self.__dict__['_all_attrs'] = self._add_attrs(self, {name: value}) self.__dict__[name] = value class BoundFactory(BoundAttribute): """ This will bind the attribute to whatever is given by ``factory_class``. This factory should be a callable with the signature ``factory_class(added_class, attr_name, *args, **kw)``. The factory will be reinvoked (and the attribute rebound) for every subclassing. """ factory_class = None _private_variables = ( BoundAttribute._private_variables + ('factory_class',)) def make_object(cls, added_class, attr_name, *args, **kw): return cls.factory_class(added_class, attr_name, *args, **kw) SQLObject-3.1.0/sqlobject/col.py0000644000175000017500000017736612752477506016031 0ustar phdphd00000000000000""" Col -- SQLObject columns Note that each column object is named BlahBlahCol, and these are used in class definitions. But there's also a corresponding SOBlahBlahCol object, which is used in SQLObject *classes*. An explanation: when a SQLObject subclass is created, the metaclass looks through your class definition for any subclasses of Col. It collects them together, and indexes them to do all the database stuff you like, like the magic attributes and whatnot. It then asks the Col object to create an SOCol object (usually a subclass, actually). The SOCol object contains all the interesting logic, as well as a record of the attribute name you used and the class it is bound to (set by the metaclass). So, in summary: Col objects are what you define, but SOCol objects are what gets used. """ from array import array from decimal import Decimal from itertools import count import json try: import cPickle as pickle except ImportError: import pickle import time from uuid import UUID import weakref from formencode import compound, validators from .classregistry import findClass # Sadly the name "constraints" conflicts with many of the function # arguments in this module, so we rename it: from . import constraints as constrs from . import converters from . import sqlbuilder from .styles import capword from .compat import PY2, string_type, unicode_type, buffer_type import datetime datetime_available = True try: from mx import DateTime except ImportError: try: # old version of mxDateTime, # or Zope's Version if we're running with Zope import DateTime except ImportError: mxdatetime_available = False else: mxdatetime_available = True else: mxdatetime_available = True DATETIME_IMPLEMENTATION = "datetime" MXDATETIME_IMPLEMENTATION = "mxDateTime" if mxdatetime_available: if hasattr(DateTime, "Time"): DateTimeType = type(DateTime.now()) TimeType = type(DateTime.Time()) else: # Zope DateTimeType = type(DateTime.DateTime()) TimeType = type(DateTime.DateTime.Time(DateTime.DateTime())) __all__ = ["datetime_available", "mxdatetime_available", "default_datetime_implementation", "DATETIME_IMPLEMENTATION"] if mxdatetime_available: __all__.append("MXDATETIME_IMPLEMENTATION") default_datetime_implementation = DATETIME_IMPLEMENTATION if not PY2: # alias for python 3 compatibility long = int # This is to satisfy flake8 under python 3 unicode = str NoDefault = sqlbuilder.NoDefault def use_microseconds(use=True): if use: SODateTimeCol.datetimeFormat = '%Y-%m-%d %H:%M:%S.%f' SOTimeCol.timeFormat = '%H:%M:%S.%f' dt_types = [(datetime.datetime, converters.DateTimeConverterMS), (datetime.time, converters.TimeConverterMS)] else: SODateTimeCol.datetimeFormat = '%Y-%m-%d %H:%M:%S' SOTimeCol.timeFormat = '%H:%M:%S' dt_types = [(datetime.datetime, converters.DateTimeConverter), (datetime.time, converters.TimeConverter)] for dt_type, converter in dt_types: converters.registerConverter(dt_type, converter) __all__.append("use_microseconds") creationOrder = count() ######################################## # Columns ######################################## # Col is essentially a column definition, it doesn't have much logic to it. class SOCol(object): def __init__(self, name, soClass, creationOrder, dbName=None, default=NoDefault, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=NoDefault, notNone=NoDefault, unique=NoDefault, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None): super(SOCol, self).__init__() # This isn't strictly true, since we *could* use backquotes or # " or something (database-specific) around column names, but # why would anyone *want* to use a name like that? # @@: I suppose we could actually add backquotes to the # dbName if we needed to... if not forceDBName: assert sqlbuilder.sqlIdentifier(name), ( 'Name must be SQL-safe ' '(letters, numbers, underscores): %s (or use forceDBName=True)' % repr(name)) assert name != 'id', ( 'The column name "id" is reserved for SQLObject use ' '(and is implicitly created).') assert name, "You must provide a name for all columns" self.columnDef = columnDef self.creationOrder = creationOrder self.immutable = immutable # cascade can be one of: # None: no constraint is generated # True: a CASCADE constraint is generated # False: a RESTRICT constraint is generated # 'null': a SET NULL trigger is generated if isinstance(cascade, str): assert cascade == 'null', ( "The only string value allowed for cascade is 'null' " "(you gave: %r)" % cascade) self.cascade = cascade if not isinstance(constraints, (list, tuple)): constraints = [constraints] self.constraints = self.autoConstraints() + constraints self.notNone = False if notNull is not NoDefault: self.notNone = notNull assert notNone is NoDefault or (not notNone) == (not notNull), ( "The notNull and notNone arguments are aliases, " "and must not conflict. " "You gave notNull=%r, notNone=%r" % (notNull, notNone)) elif notNone is not NoDefault: self.notNone = notNone if self.notNone: self.constraints = [constrs.notNull] + self.constraints self.name = name self.soClass = soClass self._default = default self.defaultSQL = defaultSQL self.customSQLType = sqlType # deal with foreign keys self.foreignKey = foreignKey if self.foreignKey: if origName is not None: idname = soClass.sqlmeta.style.instanceAttrToIDAttr(origName) else: idname = soClass.sqlmeta.style.instanceAttrToIDAttr(name) if self.name != idname: self.foreignName = self.name self.name = idname else: self.foreignName = soClass.sqlmeta.style.\ instanceIDAttrToAttr(self.name) else: self.foreignName = None # if they don't give us a specific database name for # the column, we separate the mixedCase into mixed_case # and assume that. if dbName is None: self.dbName = soClass.sqlmeta.style.pythonAttrToDBColumn(self.name) else: self.dbName = dbName # alternateID means that this is a unique column that # can be used to identify rows self.alternateID = alternateID if unique is NoDefault: self.unique = alternateID else: self.unique = unique if self.unique and alternateMethodName is None: self.alternateMethodName = 'by' + capword(self.name) else: self.alternateMethodName = alternateMethodName _validators = self.createValidators() if validator: _validators.append(validator) if validator2: _validators.insert(0, validator2) _vlen = len(_validators) if _vlen: for _validator in _validators: _validator.soCol = weakref.proxy(self) if _vlen == 0: self.validator = None # Set sef.{from,to}_python elif _vlen == 1: self.validator = _validators[0] elif _vlen > 1: self.validator = compound.All.join( _validators[0], *_validators[1:]) self.noCache = noCache self.lazy = lazy # this is in case of ForeignKey, where we rename the column # and append an ID self.origName = origName or name self.title = title self.tags = tags self.dbEncoding = dbEncoding if extra_vars: for name, value in extra_vars.items(): setattr(self, name, value) def _set_validator(self, value): self._validator = value if self._validator: self.to_python = self._validator.to_python self.from_python = self._validator.from_python else: self.to_python = None self.from_python = None def _get_validator(self): return self._validator validator = property(_get_validator, _set_validator) def createValidators(self): """Create a list of validators for the column.""" return [] def autoConstraints(self): return [] def _get_default(self): # A default can be a callback or a plain value, # here we resolve the callback if self._default is NoDefault: return NoDefault elif hasattr(self._default, '__sqlrepr__'): return self._default elif callable(self._default): return self._default() else: return self._default default = property(_get_default, None, None) def _get_joinName(self): return self.soClass.sqlmeta.style.instanceIDAttrToAttr(self.name) joinName = property(_get_joinName, None, None) def __repr__(self): r = '<%s %s' % (self.__class__.__name__, self.name) if self.default is not NoDefault: r += ' default=%s' % repr(self.default) if self.foreignKey: r += ' connected to %s' % self.foreignKey if self.alternateID: r += ' alternate ID' if self.notNone: r += ' not null' return r + '>' def createSQL(self): return ' '.join([self._sqlType()] + self._extraSQL()) def _extraSQL(self): result = [] if self.notNone or self.alternateID: result.append('NOT NULL') if self.unique or self.alternateID: result.append('UNIQUE') if self.defaultSQL is not None: result.append("DEFAULT %s" % self.defaultSQL) return result def _sqlType(self): if self.customSQLType is None: raise ValueError("Col %s (%s) cannot be used for automatic " "schema creation (too abstract)" % (self.name, self.__class__)) else: return self.customSQLType def _mysqlType(self): return self._sqlType() def _postgresType(self): return self._sqlType() def _sqliteType(self): # SQLite is naturally typeless, so as a fallback it uses # no type. try: return self._sqlType() except ValueError: return '' def _sybaseType(self): return self._sqlType() def _mssqlType(self): return self._sqlType() def _firebirdType(self): return self._sqlType() def _maxdbType(self): return self._sqlType() def mysqlCreateSQL(self, connection=None): self.connection = connection return ' '.join([self.dbName, self._mysqlType()] + self._extraSQL()) def postgresCreateSQL(self): return ' '.join([self.dbName, self._postgresType()] + self._extraSQL()) def sqliteCreateSQL(self): return ' '.join([self.dbName, self._sqliteType()] + self._extraSQL()) def sybaseCreateSQL(self): return ' '.join([self.dbName, self._sybaseType()] + self._extraSQL()) def mssqlCreateSQL(self, connection=None): self.connection = connection return ' '.join([self.dbName, self._mssqlType()] + self._extraSQL()) def firebirdCreateSQL(self): # Ian Sparks pointed out that fb is picky about the order # of the NOT NULL clause in a create statement. So, we handle # them differently for Enum columns. if not isinstance(self, SOEnumCol): return ' '.join( [self.dbName, self._firebirdType()] + self._extraSQL()) else: return ' '.join( [self.dbName] + [self._firebirdType()[0]] + self._extraSQL() + [self._firebirdType()[1]]) def maxdbCreateSQL(self): return ' '.join([self.dbName, self._maxdbType()] + self._extraSQL()) def __get__(self, obj, type=None): if obj is None: # class attribute, return the descriptor itself return self if obj.sqlmeta._obsolete: raise RuntimeError('The object <%s %s> is obsolete' % ( obj.__class__.__name__, obj.id)) if obj.sqlmeta.cacheColumns: columns = obj.sqlmeta._columnCache if columns is None: obj.sqlmeta.loadValues() try: return columns[name] # noqa except KeyError: return obj.sqlmeta.loadColumn(self) else: return obj.sqlmeta.loadColumn(self) def __set__(self, obj, value): if self.immutable: raise AttributeError("The column %s.%s is immutable" % (obj.__class__.__name__, self.name)) obj.sqlmeta.setColumn(self, value) def __delete__(self, obj): raise AttributeError("I can't be deleted from %r" % obj) def getDbEncoding(self, state, default='utf-8'): if self.dbEncoding: return self.dbEncoding dbEncoding = state.soObject.sqlmeta.dbEncoding if dbEncoding: return dbEncoding try: connection = state.connection or state.soObject._connection except AttributeError: dbEncoding = None else: dbEncoding = getattr(connection, "dbEncoding", None) if not dbEncoding: dbEncoding = default return dbEncoding class Col(object): baseClass = SOCol def __init__(self, name=None, **kw): super(Col, self).__init__() self.__dict__['_name'] = name self.__dict__['_kw'] = kw self.__dict__['creationOrder'] = next(creationOrder) self.__dict__['_extra_vars'] = {} def _set_name(self, value): assert self._name is None or self._name == value, ( "You cannot change a name after it has already been set " "(from %s to %s)" % (self.name, value)) self.__dict__['_name'] = value def _get_name(self): return self._name name = property(_get_name, _set_name) def withClass(self, soClass): return self.baseClass(soClass=soClass, name=self._name, creationOrder=self.creationOrder, columnDef=self, extra_vars=self._extra_vars, **self._kw) def __setattr__(self, var, value): if var == 'name': super(Col, self).__setattr__(var, value) return self._extra_vars[var] = value def __repr__(self): return '<%s %s %s>' % ( self.__class__.__name__, hex(abs(id(self)))[2:], self._name or '(unnamed)') class SOValidator(validators.Validator): def getDbEncoding(self, state, default='utf-8'): try: return self.dbEncoding except AttributeError: return self.soCol.getDbEncoding(state, default=default) class SOStringLikeCol(SOCol): """A common ancestor for SOStringCol and SOUnicodeCol""" def __init__(self, **kw): self.length = kw.pop('length', None) self.varchar = kw.pop('varchar', 'auto') self.char_binary = kw.pop('char_binary', None) # A hack for MySQL if not self.length: assert self.varchar == 'auto' or not self.varchar, \ "Without a length strings are treated as TEXT, not varchar" self.varchar = False elif self.varchar == 'auto': self.varchar = True super(SOStringLikeCol, self).__init__(**kw) def autoConstraints(self): constraints = [constrs.isString] if self.length is not None: constraints += [constrs.MaxLength(self.length)] return constraints def _sqlType(self): if self.customSQLType is not None: return self.customSQLType if not self.length: return 'TEXT' elif self.varchar: return 'VARCHAR(%i)' % self.length else: return 'CHAR(%i)' % self.length def _check_case_sensitive(self, db): if self.char_binary: raise ValueError("%s does not support " "binary character columns" % db) def _mysqlType(self): type = self._sqlType() if self.char_binary: type += " BINARY" return type def _postgresType(self): self._check_case_sensitive("PostgreSQL") return super(SOStringLikeCol, self)._postgresType() def _sqliteType(self): self._check_case_sensitive("SQLite") return super(SOStringLikeCol, self)._sqliteType() def _sybaseType(self): self._check_case_sensitive("SYBASE") type = self._sqlType() if not self.notNone and not self.alternateID: type += ' NULL' return type def _mssqlType(self): if self.customSQLType is not None: return self.customSQLType if not self.length: if self.connection and self.connection.can_use_max_types(): type = 'VARCHAR(MAX)' else: type = 'VARCHAR(4000)' elif self.varchar: type = 'VARCHAR(%i)' % self.length else: type = 'CHAR(%i)' % self.length if not self.notNone and not self.alternateID: type += ' NULL' return type def _firebirdType(self): self._check_case_sensitive("FireBird") if not self.length: return 'BLOB SUB_TYPE TEXT' else: return self._sqlType() def _maxdbType(self): self._check_case_sensitive("SAP DB/MaxDB") if not self.length: return 'LONG ASCII' else: return self._sqlType() class StringValidator(SOValidator): def to_python(self, value, state): if value is None: return None try: connection = state.connection or state.soObject._connection binaryType = connection._binaryType dbName = connection.dbName except AttributeError: binaryType = type(None) # Just a simple workaround dbEncoding = self.getDbEncoding(state, default='ascii') if isinstance(value, unicode_type): if PY2: return value.encode(dbEncoding) return value if self.dataType and isinstance(value, self.dataType): return value if isinstance(value, (str, buffer_type, binaryType, sqlbuilder.SQLExpression)): return value if hasattr(value, '__unicode__'): return unicode(value).encode(dbEncoding) if dbName == 'mysql' and not PY2 and isinstance(value, bytes): return value.decode('ascii', errors='surrogateescape') raise validators.Invalid( "expected a str in the StringCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) from_python = to_python class SOStringCol(SOStringLikeCol): def createValidators(self, dataType=None): return [StringValidator(name=self.name, dataType=dataType)] + \ super(SOStringCol, self).createValidators() class StringCol(Col): baseClass = SOStringCol class NQuoted(sqlbuilder.SQLExpression): def __init__(self, value): assert isinstance(value, unicode_type) self.value = value def __hash__(self): return hash(self.value) def __sqlrepr__(self, db): assert db == 'mssql' return "N" + sqlbuilder.sqlrepr(self.value, db) class UnicodeStringValidator(SOValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (unicode_type, sqlbuilder.SQLExpression)): return value if isinstance(value, str): return value.decode(self.getDbEncoding(state)) if isinstance(value, array): # MySQL return value.tostring().decode(self.getDbEncoding(state)) if hasattr(value, '__unicode__'): return unicode(value) raise validators.Invalid( "expected a str or a unicode in the UnicodeCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None if isinstance(value, (str, sqlbuilder.SQLExpression)): return value if isinstance(value, unicode_type): try: connection = state.connection or state.soObject._connection except AttributeError: pass else: if connection.dbName == 'mssql': return NQuoted(value) return value.encode(self.getDbEncoding(state)) if hasattr(value, '__unicode__'): return unicode(value).encode(self.getDbEncoding(state)) raise validators.Invalid( "expected a str or a unicode in the UnicodeCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) class SOUnicodeCol(SOStringLikeCol): def _mssqlType(self): if self.customSQLType is not None: return self.customSQLType return 'N' + super(SOUnicodeCol, self)._mssqlType() def createValidators(self): return [UnicodeStringValidator(name=self.name)] + \ super(SOUnicodeCol, self).createValidators() class UnicodeCol(Col): baseClass = SOUnicodeCol class IntValidator(SOValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (int, long, sqlbuilder.SQLExpression)): return value for converter, attr_name in (int, '__int__'), (long, '__long__'): if hasattr(value, attr_name): try: return converter(value) except: break raise validators.Invalid( "expected an int in the IntCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) from_python = to_python class SOIntCol(SOCol): # 3-03 @@: support precision, maybe max and min directly def __init__(self, **kw): self.length = kw.pop('length', None) self.unsigned = bool(kw.pop('unsigned', None)) self.zerofill = bool(kw.pop('zerofill', None)) SOCol.__init__(self, **kw) def autoConstraints(self): return [constrs.isInt] def createValidators(self): return [IntValidator(name=self.name)] + \ super(SOIntCol, self).createValidators() def addSQLAttrs(self, str): _ret = str if str is None or len(str) < 1: return None if self.length and self.length >= 1: _ret = "%s(%d)" % (_ret, self.length) if self.unsigned: _ret = _ret + " UNSIGNED" if self.zerofill: _ret = _ret + " ZEROFILL" return _ret def _sqlType(self): return self.addSQLAttrs("INT") class IntCol(Col): baseClass = SOIntCol class SOTinyIntCol(SOIntCol): def _sqlType(self): return self.addSQLAttrs("TINYINT") class TinyIntCol(Col): baseClass = SOTinyIntCol class SOSmallIntCol(SOIntCol): def _sqlType(self): return self.addSQLAttrs("SMALLINT") class SmallIntCol(Col): baseClass = SOSmallIntCol class SOMediumIntCol(SOIntCol): def _sqlType(self): return self.addSQLAttrs("MEDIUMINT") class MediumIntCol(Col): baseClass = SOMediumIntCol class SOBigIntCol(SOIntCol): def _sqlType(self): return self.addSQLAttrs("BIGINT") class BigIntCol(Col): baseClass = SOBigIntCol class BoolValidator(SOValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (bool, sqlbuilder.SQLExpression)): return value if isinstance(value, (int, long)) or hasattr(value, '__nonzero__'): return bool(value) raise validators.Invalid( "expected a bool or an int in the BoolCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) from_python = to_python class SOBoolCol(SOCol): def autoConstraints(self): return [constrs.isBool] def createValidators(self): return [BoolValidator(name=self.name)] + \ super(SOBoolCol, self).createValidators() def _postgresType(self): return 'BOOL' def _mysqlType(self): return "BOOL" def _sybaseType(self): return "BIT" def _mssqlType(self): return "BIT" def _firebirdType(self): return 'INT' def _maxdbType(self): return "BOOLEAN" def _sqliteType(self): return "BOOLEAN" class BoolCol(Col): baseClass = SOBoolCol class FloatValidator(SOValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (float, int, long, sqlbuilder.SQLExpression)): return value for converter, attr_name in ( (float, '__float__'), (int, '__int__'), (long, '__long__')): if hasattr(value, attr_name): try: return converter(value) except: break raise validators.Invalid( "expected a float in the FloatCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) from_python = to_python class SOFloatCol(SOCol): # 3-03 @@: support precision (e.g., DECIMAL) def autoConstraints(self): return [constrs.isFloat] def createValidators(self): return [FloatValidator(name=self.name)] + \ super(SOFloatCol, self).createValidators() def _sqlType(self): return 'FLOAT' def _mysqlType(self): return "DOUBLE PRECISION" class FloatCol(Col): baseClass = SOFloatCol class SOKeyCol(SOCol): key_type = {int: "INT", str: "TEXT"} # 3-03 @@: this should have a simplified constructor # Should provide foreign key information for other DBs. def __init__(self, **kw): self.refColumn = kw.pop('refColumn', None) super(SOKeyCol, self).__init__(**kw) def _idType(self): return self.soClass.sqlmeta.idType def _sqlType(self): return self.key_type[self._idType()] def _sybaseType(self): key_type = {int: "NUMERIC(18,0) NULL", str: "TEXT"} return key_type[self._idType()] def _mssqlType(self): key_type = {int: "INT NULL", str: "TEXT"} return key_type[self._idType()] class KeyCol(Col): baseClass = SOKeyCol class ForeignKeyValidator(SOValidator): def __init__(self, *args, **kw): super(ForeignKeyValidator, self).__init__(*args, **kw) self.fkIDType = None def from_python(self, value, state): if value is None: return None # Avoid importing the main module # to get the SQLObject class for isinstance if hasattr(value, 'sqlmeta'): return value if self.fkIDType is None: otherTable = findClass(self.soCol.foreignKey, self.soCol.soClass.sqlmeta.registry) self.fkIDType = otherTable.sqlmeta.idType try: value = self.fkIDType(value) return value except (ValueError, TypeError): pass raise validators.Invalid("expected a %r for the ForeignKey '%s', " "got %s %r instead" % (self.fkIDType, self.name, type(value), value), value, state) class SOForeignKey(SOKeyCol): def __init__(self, **kw): foreignKey = kw['foreignKey'] style = kw['soClass'].sqlmeta.style if kw.get('name'): kw['origName'] = kw['name'] kw['name'] = style.instanceAttrToIDAttr(kw['name']) else: kw['name'] = style.instanceAttrToIDAttr( style.pythonClassToAttr(foreignKey)) super(SOForeignKey, self).__init__(**kw) def createValidators(self): return [ForeignKeyValidator(name=self.name)] + \ super(SOForeignKey, self).createValidators() def _idType(self): other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) return other.sqlmeta.idType def sqliteCreateSQL(self): sql = SOKeyCol.sqliteCreateSQL(self) other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) tName = other.sqlmeta.table idName = self.refColumn or other.sqlmeta.idName if self.cascade is not None: if self.cascade == 'null': action = 'ON DELETE SET NULL' elif self.cascade: action = 'ON DELETE CASCADE' else: action = 'ON DELETE RESTRICT' else: action = '' constraint = ('CONSTRAINT %(colName)s_exists ' # 'FOREIGN KEY(%(colName)s) ' 'REFERENCES %(tName)s(%(idName)s) ' '%(action)s' % {'tName': tName, 'colName': self.dbName, 'idName': idName, 'action': action}) sql = ' '.join([sql, constraint]) return sql def postgresCreateSQL(self): sql = SOKeyCol.postgresCreateSQL(self) return sql def postgresCreateReferenceConstraint(self): sTName = self.soClass.sqlmeta.table other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) tName = other.sqlmeta.table idName = self.refColumn or other.sqlmeta.idName if self.cascade is not None: if self.cascade == 'null': action = 'ON DELETE SET NULL' elif self.cascade: action = 'ON DELETE CASCADE' else: action = 'ON DELETE RESTRICT' else: action = '' constraint = ('ALTER TABLE %(sTName)s ' 'ADD CONSTRAINT %(colName)s_exists ' 'FOREIGN KEY (%(colName)s) ' 'REFERENCES %(tName)s (%(idName)s) ' '%(action)s' % {'tName': tName, 'colName': self.dbName, 'idName': idName, 'action': action, 'sTName': sTName}) return constraint def mysqlCreateReferenceConstraint(self): sTName = self.soClass.sqlmeta.table sTLocalName = sTName.split('.')[-1] other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) tName = other.sqlmeta.table idName = self.refColumn or other.sqlmeta.idName if self.cascade is not None: if self.cascade == 'null': action = 'ON DELETE SET NULL' elif self.cascade: action = 'ON DELETE CASCADE' else: action = 'ON DELETE RESTRICT' else: action = '' constraint = ('ALTER TABLE %(sTName)s ' 'ADD CONSTRAINT %(sTLocalName)s_%(colName)s_exists ' 'FOREIGN KEY (%(colName)s) ' 'REFERENCES %(tName)s (%(idName)s) ' '%(action)s' % {'tName': tName, 'colName': self.dbName, 'idName': idName, 'action': action, 'sTName': sTName, 'sTLocalName': sTLocalName}) return constraint def mysqlCreateSQL(self, connection=None): return SOKeyCol.mysqlCreateSQL(self, connection) def sybaseCreateSQL(self): sql = SOKeyCol.sybaseCreateSQL(self) other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) tName = other.sqlmeta.table idName = self.refColumn or other.sqlmeta.idName reference = ('REFERENCES %(tName)s(%(idName)s) ' % {'tName': tName, 'idName': idName}) sql = ' '.join([sql, reference]) return sql def sybaseCreateReferenceConstraint(self): # @@: Code from above should be moved here return None def mssqlCreateSQL(self, connection=None): sql = SOKeyCol.mssqlCreateSQL(self, connection) other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) tName = other.sqlmeta.table idName = self.refColumn or other.sqlmeta.idName reference = ('REFERENCES %(tName)s(%(idName)s) ' % {'tName': tName, 'idName': idName}) sql = ' '.join([sql, reference]) return sql def mssqlCreateReferenceConstraint(self): # @@: Code from above should be moved here return None def maxdbCreateSQL(self): other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) fidName = self.dbName # I assume that foreign key name is identical # to the id of the reference table sql = ' '.join([fidName, self._maxdbType()]) tName = other.sqlmeta.table idName = self.refColumn or other.sqlmeta.idName sql = sql + ',' + '\n' sql = sql + 'FOREIGN KEY (%s) REFERENCES %s(%s)' % (fidName, tName, idName) return sql def maxdbCreateReferenceConstraint(self): # @@: Code from above should be moved here return None class ForeignKey(KeyCol): baseClass = SOForeignKey def __init__(self, foreignKey=None, **kw): super(ForeignKey, self).__init__(foreignKey=foreignKey, **kw) class EnumValidator(SOValidator): def to_python(self, value, state): if value in self.enumValues: # Only encode on python 2 - on python 3, the database driver # will handle this if isinstance(value, unicode_type) and PY2: dbEncoding = self.getDbEncoding(state) value = value.encode(dbEncoding) return value elif not self.notNone and value is None: return None raise validators.Invalid( "expected a member of %r in the EnumCol '%s', got %r instead" % ( self.enumValues, self.name, value), value, state) from_python = to_python class SOEnumCol(SOCol): def __init__(self, **kw): self.enumValues = kw.pop('enumValues', None) assert self.enumValues is not None, \ 'You must provide an enumValues keyword argument' super(SOEnumCol, self).__init__(**kw) def autoConstraints(self): return [constrs.isString, constrs.InList(self.enumValues)] def createValidators(self): return [EnumValidator(name=self.name, enumValues=self.enumValues, notNone=self.notNone)] + \ super(SOEnumCol, self).createValidators() def _mysqlType(self): # We need to map None in the enum expression to an appropriate # condition on NULL if None in self.enumValues: return "ENUM(%s)" % ', '.join( [sqlbuilder.sqlrepr(v, 'mysql') for v in self.enumValues if v is not None]) else: return "ENUM(%s) NOT NULL" % ', '.join( [sqlbuilder.sqlrepr(v, 'mysql') for v in self.enumValues]) def _postgresType(self): length = max(map(self._getlength, self.enumValues)) enumValues = ', '.join( [sqlbuilder.sqlrepr(v, 'postgres') for v in self.enumValues]) checkConstraint = "CHECK (%s in (%s))" % (self.dbName, enumValues) return "VARCHAR(%i) %s" % (length, checkConstraint) _sqliteType = _postgresType def _sybaseType(self): return self._postgresType() def _mssqlType(self): return self._postgresType() def _firebirdType(self): length = max(map(self._getlength, self.enumValues)) enumValues = ', '.join( [sqlbuilder.sqlrepr(v, 'firebird') for v in self.enumValues]) checkConstraint = "CHECK (%s in (%s))" % (self.dbName, enumValues) # NB. Return a tuple, not a string here return "VARCHAR(%i)" % (length), checkConstraint def _maxdbType(self): raise TypeError("Enum type is not supported on MAX DB") def _getlength(self, obj): """ None counts as 0; everything else uses len() """ if obj is None: return 0 else: return len(obj) class EnumCol(Col): baseClass = SOEnumCol class SetValidator(SOValidator): """ Translates Python tuples into SQL comma-delimited SET strings. """ def to_python(self, value, state): if isinstance(value, str): return tuple(value.split(",")) raise validators.Invalid( "expected a string in the SetCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if isinstance(value, string_type): value = (value,) try: return ",".join(value) except: raise validators.Invalid( "expected a string or a sequence of strings " "in the SetCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) class SOSetCol(SOCol): def __init__(self, **kw): self.setValues = kw.pop('setValues', None) assert self.setValues is not None, \ 'You must provide a setValues keyword argument' super(SOSetCol, self).__init__(**kw) def autoConstraints(self): return [constrs.isString, constrs.InList(self.setValues)] def createValidators(self): return [SetValidator(name=self.name, setValues=self.setValues)] + \ super(SOSetCol, self).createValidators() def _mysqlType(self): return "SET(%s)" % ', '.join( [sqlbuilder.sqlrepr(v, 'mysql') for v in self.setValues]) class SetCol(Col): baseClass = SOSetCol class DateTimeValidator(validators.DateValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (datetime.datetime, datetime.date, datetime.time, sqlbuilder.SQLExpression)): return value if mxdatetime_available: if isinstance(value, DateTimeType): # convert mxDateTime instance to datetime if (self.format.find("%H") >= 0) or \ (self.format.find("%T")) >= 0: return datetime.datetime(value.year, value.month, value.day, value.hour, value.minute, int(value.second)) else: return datetime.date(value.year, value.month, value.day) elif isinstance(value, TimeType): # convert mxTime instance to time if self.format.find("%d") >= 0: return datetime.timedelta(seconds=value.seconds) else: return datetime.time(value.hour, value.minute, int(value.second)) try: if self.format.find(".%f") >= 0: if '.' in value: _value = value.split('.') microseconds = _value[-1] _l = len(microseconds) if _l < 6: _value[-1] = microseconds + '0' * (6 - _l) elif _l > 6: _value[-1] = microseconds[:6] if _l != 6: value = '.'.join(_value) else: value += '.0' return datetime.datetime.strptime(value, self.format) except: raise validators.Invalid( "expected a date/time string of the '%s' format " "in the DateTimeCol '%s', got %s %r instead" % ( self.format, self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None if isinstance(value, (datetime.datetime, datetime.date, datetime.time, sqlbuilder.SQLExpression)): return value if hasattr(value, "strftime"): return value.strftime(self.format) raise validators.Invalid( "expected a datetime in the DateTimeCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) if mxdatetime_available: class MXDateTimeValidator(validators.DateValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (DateTimeType, TimeType, sqlbuilder.SQLExpression)): return value if isinstance(value, datetime.datetime): return DateTime.DateTime(value.year, value.month, value.day, value.hour, value.minute, value.second) elif isinstance(value, datetime.date): return DateTime.Date(value.year, value.month, value.day) elif isinstance(value, datetime.time): return DateTime.Time(value.hour, value.minute, value.second) elif isinstance(value, datetime.timedelta): if value.days: raise validators.Invalid( "the value for the TimeCol '%s' must has days=0, " "it has days=%d" % (self.name, value.days), value, state) return DateTime.Time(seconds=value.seconds) try: if self.format.find(".%f") >= 0: if '.' in value: _value = value.split('.') microseconds = _value[-1] _l = len(microseconds) if _l < 6: _value[-1] = microseconds + '0' * (6 - _l) elif _l > 6: _value[-1] = microseconds[:6] if _l != 6: value = '.'.join(_value) else: value += '.0' value = datetime.datetime.strptime(value, self.format) return DateTime.DateTime(value.year, value.month, value.day, value.hour, value.minute, value.second) except: raise validators.Invalid( "expected a date/time string of the '%s' format " "in the DateTimeCol '%s', got %s %r instead" % ( self.format, self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None if isinstance(value, (DateTimeType, TimeType, sqlbuilder.SQLExpression)): return value if hasattr(value, "strftime"): return value.strftime(self.format) raise validators.Invalid( "expected a mxDateTime in the DateTimeCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) class SODateTimeCol(SOCol): datetimeFormat = '%Y-%m-%d %H:%M:%S.%f' def __init__(self, **kw): datetimeFormat = kw.pop('datetimeFormat', None) if datetimeFormat: self.datetimeFormat = datetimeFormat super(SODateTimeCol, self).__init__(**kw) def createValidators(self): _validators = super(SODateTimeCol, self).createValidators() if default_datetime_implementation == DATETIME_IMPLEMENTATION: validatorClass = DateTimeValidator elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION: validatorClass = MXDateTimeValidator if default_datetime_implementation: _validators.insert(0, validatorClass(name=self.name, format=self.datetimeFormat)) return _validators def _mysqlType(self): if self.connection and self.connection.can_use_microseconds(): return 'DATETIME(6)' else: return 'DATETIME' def _postgresType(self): return 'TIMESTAMP' def _sybaseType(self): return 'DATETIME' def _mssqlType(self): if self.connection and self.connection.can_use_microseconds(): return 'DATETIME2(6)' else: return 'DATETIME' def _sqliteType(self): return 'TIMESTAMP' def _firebirdType(self): return 'TIMESTAMP' def _maxdbType(self): return 'TIMESTAMP' class DateTimeCol(Col): baseClass = SODateTimeCol @staticmethod def now(): if default_datetime_implementation == DATETIME_IMPLEMENTATION: return datetime.datetime.now() elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION: return DateTime.now() else: assert 0, ("No datetime implementation available " "(DATETIME_IMPLEMENTATION=%r)" % DATETIME_IMPLEMENTATION) class DateValidator(DateTimeValidator): def to_python(self, value, state): if isinstance(value, datetime.datetime): value = value.date() if isinstance(value, (datetime.date, sqlbuilder.SQLExpression)): return value value = super(DateValidator, self).to_python(value, state) if isinstance(value, datetime.datetime): value = value.date() return value from_python = to_python class SODateCol(SOCol): dateFormat = '%Y-%m-%d' def __init__(self, **kw): dateFormat = kw.pop('dateFormat', None) if dateFormat: self.dateFormat = dateFormat super(SODateCol, self).__init__(**kw) def createValidators(self): """Create a validator for the column. Can be overriden in descendants. """ _validators = super(SODateCol, self).createValidators() if default_datetime_implementation == DATETIME_IMPLEMENTATION: validatorClass = DateValidator elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION: validatorClass = MXDateTimeValidator if default_datetime_implementation: _validators.insert(0, validatorClass(name=self.name, format=self.dateFormat)) return _validators def _mysqlType(self): return 'DATE' def _postgresType(self): return 'DATE' def _sybaseType(self): return self._postgresType() def _mssqlType(self): """ SQL Server doesn't have a DATE data type, to emulate we use a vc(10) """ return 'VARCHAR(10)' def _firebirdType(self): return 'DATE' def _maxdbType(self): return 'DATE' def _sqliteType(self): return 'DATE' class DateCol(Col): baseClass = SODateCol class TimeValidator(DateTimeValidator): def to_python(self, value, state): if isinstance(value, (datetime.time, sqlbuilder.SQLExpression)): return value if isinstance(value, datetime.timedelta): if value.days: raise validators.Invalid( "the value for the TimeCol '%s' must has days=0, " "it has days=%d" % (self.name, value.days), value, state) return datetime.time(*time.gmtime(value.seconds)[3:6]) value = super(TimeValidator, self).to_python(value, state) if isinstance(value, datetime.datetime): value = value.time() return value from_python = to_python class SOTimeCol(SOCol): timeFormat = '%H:%M:%S.%f' def __init__(self, **kw): timeFormat = kw.pop('timeFormat', None) if timeFormat: self.timeFormat = timeFormat super(SOTimeCol, self).__init__(**kw) def createValidators(self): _validators = super(SOTimeCol, self).createValidators() if default_datetime_implementation == DATETIME_IMPLEMENTATION: validatorClass = TimeValidator elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION: validatorClass = MXDateTimeValidator if default_datetime_implementation: _validators.insert(0, validatorClass(name=self.name, format=self.timeFormat)) return _validators def _mysqlType(self): if self.connection and self.connection.can_use_microseconds(): return 'TIME(6)' else: return 'TIME' def _postgresType(self): return 'TIME' def _sybaseType(self): return 'TIME' def _mssqlType(self): if self.connection and self.connection.can_use_microseconds(): return 'TIME(6)' else: return 'TIME' def _sqliteType(self): return 'TIME' def _firebirdType(self): return 'TIME' def _maxdbType(self): return 'TIME' class TimeCol(Col): baseClass = SOTimeCol class SOTimestampCol(SODateTimeCol): """ Necessary to support MySQL's use of TIMESTAMP versus DATETIME types """ def __init__(self, **kw): if 'default' not in kw: kw['default'] = None SOCol.__init__(self, **kw) def _mysqlType(self): if self.connection and self.connection.can_use_microseconds(): return 'TIMESTAMP(6)' else: return 'TIMESTAMP' class TimestampCol(Col): baseClass = SOTimestampCol class TimedeltaValidator(SOValidator): def to_python(self, value, state): return value from_python = to_python class SOTimedeltaCol(SOCol): def _postgresType(self): return 'INTERVAL' def createValidators(self): return [TimedeltaValidator(name=self.name)] + \ super(SOTimedeltaCol, self).createValidators() class TimedeltaCol(Col): baseClass = SOTimedeltaCol class DecimalValidator(SOValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, (int, long, Decimal, sqlbuilder.SQLExpression)): return value if isinstance(value, float): value = str(value) try: connection = state.connection or state.soObject._connection except AttributeError: pass else: if hasattr(connection, "decimalSeparator"): value = value.replace(connection.decimalSeparator, ".") try: return Decimal(value) except: raise validators.Invalid( "expected a Decimal in the DecimalCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None if isinstance(value, float): value = str(value) if isinstance(value, string_type): try: connection = state.connection or state.soObject._connection except AttributeError: pass else: if hasattr(connection, "decimalSeparator"): value = value.replace(connection.decimalSeparator, ".") try: return Decimal(value) except: raise validators.Invalid( "can not parse Decimal value '%s' " "in the DecimalCol from '%s'" % ( value, getattr(state, 'soObject', '(unknown)')), value, state) if isinstance(value, (int, long, Decimal, sqlbuilder.SQLExpression)): return value raise validators.Invalid( "expected a Decimal in the DecimalCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) class SODecimalCol(SOCol): def __init__(self, **kw): self.size = kw.pop('size', NoDefault) assert self.size is not NoDefault, \ "You must give a size argument" self.precision = kw.pop('precision', NoDefault) assert self.precision is not NoDefault, \ "You must give a precision argument" super(SODecimalCol, self).__init__(**kw) def _sqlType(self): return 'DECIMAL(%i, %i)' % (self.size, self.precision) def createValidators(self): return [DecimalValidator(name=self.name)] + \ super(SODecimalCol, self).createValidators() class DecimalCol(Col): baseClass = SODecimalCol class SOCurrencyCol(SODecimalCol): def __init__(self, **kw): pushKey(kw, 'size', 10) pushKey(kw, 'precision', 2) super(SOCurrencyCol, self).__init__(**kw) class CurrencyCol(DecimalCol): baseClass = SOCurrencyCol class DecimalStringValidator(DecimalValidator): def to_python(self, value, state): value = super(DecimalStringValidator, self).to_python(value, state) if self.precision and isinstance(value, Decimal): assert value < self.max, \ "Value must be less than %s" % int(self.max) value = value.quantize(self.precision) return value def from_python(self, value, state): value = super(DecimalStringValidator, self).from_python(value, state) if isinstance(value, Decimal): if self.precision: assert value < self.max, \ "Value must be less than %s" % int(self.max) value = value.quantize(self.precision) value = value.to_eng_string() elif isinstance(value, (int, long)): value = str(value) return value class SODecimalStringCol(SOStringCol): def __init__(self, **kw): self.size = kw.pop('size', NoDefault) assert (self.size is not NoDefault) and (self.size >= 0), \ "You must give a size argument as a positive integer" self.precision = kw.pop('precision', NoDefault) assert (self.precision is not NoDefault) and (self.precision >= 0), \ "You must give a precision argument as a positive integer" kw['length'] = int(self.size) + int(self.precision) self.quantize = kw.pop('quantize', False) assert isinstance(self.quantize, bool), \ "quantize argument must be Boolean True/False" super(SODecimalStringCol, self).__init__(**kw) def createValidators(self): if self.quantize: v = DecimalStringValidator( name=self.name, precision=Decimal(10) ** (-1 * int(self.precision)), max=Decimal(10) ** (int(self.size) - int(self.precision))) else: v = DecimalStringValidator(name=self.name, precision=0) return [v] + \ super(SODecimalStringCol, self).createValidators(dataType=Decimal) class DecimalStringCol(StringCol): baseClass = SODecimalStringCol class BinaryValidator(SOValidator): """ Validator for binary types. We're assuming that the per-database modules provide some form of wrapper type for binary conversion. """ _cachedValue = None def to_python(self, value, state): if value is None: return None try: connection = state.connection or state.soObject._connection except AttributeError: dbName = None binaryType = type(None) # Just a simple workaround else: dbName = connection.dbName binaryType = connection._binaryType if isinstance(value, str): if dbName == "sqlite": if not PY2: value = bytes(value, 'ascii') value = connection.module.decode(value) if dbName == "mysql" and not PY2: value = value.encode('ascii', errors='surrogateescape') return value if isinstance(value, (buffer_type, binaryType)): cachedValue = self._cachedValue if cachedValue and cachedValue[1] == value: return cachedValue[0] if isinstance(value, array): # MySQL return value.tostring() if not PY2 and isinstance(value, memoryview): return value.tobytes() return str(value) # buffer => string raise validators.Invalid( "expected a string in the BLOBCol '%s', got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None connection = state.connection or state.soObject._connection binary = connection.createBinary(value) if not PY2 and isinstance(binary, memoryview): binary = str(binary.tobytes(), 'ascii') self._cachedValue = (value, binary) return binary class SOBLOBCol(SOStringCol): def __init__(self, **kw): # Change the default from 'auto' to False - # this is a (mostly) binary column if 'varchar' not in kw: kw['varchar'] = False super(SOBLOBCol, self).__init__(**kw) def createValidators(self): return [BinaryValidator(name=self.name)] + \ super(SOBLOBCol, self).createValidators() def _mysqlType(self): length = self.length varchar = self.varchar if length: if length >= 2 ** 24: return varchar and "LONGTEXT" or "LONGBLOB" if length >= 2 ** 16: return varchar and "MEDIUMTEXT" or "MEDIUMBLOB" if length >= 2 ** 8: return varchar and "TEXT" or "BLOB" return varchar and "TINYTEXT" or "TINYBLOB" def _postgresType(self): return 'BYTEA' def _mssqlType(self): if self.connection and self.connection.can_use_max_types(): return 'VARBINARY(MAX)' else: return "IMAGE" class BLOBCol(StringCol): baseClass = SOBLOBCol class PickleValidator(BinaryValidator): """ Validator for pickle types. A pickle type is simply a binary type with hidden pickling, so that we can simply store any kind of stuff in a particular column. The support for this relies directly on the support for binary for your database. """ def to_python(self, value, state): if value is None: return None if isinstance(value, unicode_type): dbEncoding = self.getDbEncoding(state, default='ascii') value = value.encode(dbEncoding) if isinstance(value, bytes): return pickle.loads(value) raise validators.Invalid( "expected a pickle string in the PickleCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None return pickle.dumps(value, self.pickleProtocol) class SOPickleCol(SOBLOBCol): def __init__(self, **kw): self.pickleProtocol = kw.pop('pickleProtocol', pickle.HIGHEST_PROTOCOL) super(SOPickleCol, self).__init__(**kw) def createValidators(self): return [PickleValidator(name=self.name, pickleProtocol=self.pickleProtocol)] + \ super(SOPickleCol, self).createValidators() def _mysqlType(self): length = self.length if length: if length >= 2 ** 24: return "LONGBLOB" if length >= 2 ** 16: return "MEDIUMBLOB" return "BLOB" class PickleCol(BLOBCol): baseClass = SOPickleCol class UuidValidator(SOValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, str): return UUID(value) raise validators.Invalid( "expected string in the UuidCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None if isinstance(value, UUID): return str(value) raise validators.Invalid( "expected uuid in the UuidCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) class SOUuidCol(SOCol): def createValidators(self): return [UuidValidator(name=self.name)] + \ super(SOUuidCol, self).createValidators() def _sqlType(self): return 'VARCHAR(36)' def _postgresType(self): return 'UUID' class UuidCol(Col): baseClass = SOUuidCol class JsonbValidator(SOValidator): def to_python(self, value, state): return value def from_python(self, value, state): if value is None: return json.dumps(None) if isinstance(value, (dict, list, unicode, int, long, float, bool)): return json.dumps(value) raise validators.Invalid( "expect one of the following types " "(dict, list, unicode, int, long, float, bool) for '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) class SOJsonbCol(SOCol): def createValidators(self): return [JsonbValidator(name=self.name)] + \ super(SOJsonbCol, self).createValidators() def _postgresType(self): return 'JSONB' class JsonbCol(Col): baseClass = SOJsonbCol class JSONValidator(StringValidator): def to_python(self, value, state): if value is None: return None if isinstance(value, string_type): return json.loads(value) raise validators.Invalid( "expected a JSON str in the JSONCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) def from_python(self, value, state): if value is None: return None if isinstance(value, (bool, int, float, long, dict, list, string_type)): return json.dumps(value) raise validators.Invalid( "expected an object suitable for JSON in the JSONCol '%s', " "got %s %r instead" % ( self.name, type(value), value), value, state) class SOJSONCol(SOStringCol): def createValidators(self): return [JSONValidator(name=self.name)] + \ super(SOJSONCol, self).createValidators() class JSONCol(StringCol): baseClass = SOJSONCol def pushKey(kw, name, value): if name not in kw: kw[name] = value all = [] # Use copy() to avoid 'dictionary changed' issues on python 3 for key, value in globals().copy().items(): if isinstance(value, type) and (issubclass(value, (Col, SOCol))): all.append(key) __all__.extend(all) del all SQLObject-3.1.0/sqlobject/mssql/0000755000175000017500000000000012754657361016016 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/mssql/__init__.py0000644000175000017500000000027412464733165020125 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import mssqlconnection return mssqlconnection.MSSQLConnection registerConnection(['mssql'], builder) SQLObject-3.1.0/sqlobject/mssql/mssqlconnection.py0000644000175000017500000003031412540340565021574 0ustar phdphd00000000000000from sqlobject.dbconnection import DBAPI from sqlobject import col import re class MSSQLConnection(DBAPI): supportTransactions = True dbName = 'mssql' schemes = [dbName] limit_re = re.compile('^\s*(select )(.*)', re.IGNORECASE) def __init__(self, db, user, password='', host='localhost', port=None, autoCommit=0, **kw): drivers = kw.pop('driver', None) or 'adodb,pymssql' for driver in drivers.split(','): driver = driver.strip() if not driver: continue try: if driver in ('adodb', 'adodbapi'): import adodbapi as sqlmodule elif driver == 'pymssql': import pymssql as sqlmodule else: raise ValueError( 'Unknown MSSQL driver "%s", ' 'expected adodb or pymssql' % driver) except ImportError: pass else: break else: raise ImportError( 'Cannot find an MSSQL driver, tried %s' % drivers) self.module = sqlmodule if sqlmodule.__name__ == 'adodbapi': self.dbconnection = sqlmodule.connect # ADO uses unicode only (AFAIK) self.usingUnicodeStrings = True # Need to use SQLNCLI provider for SQL Server Express Edition if kw.get("ncli"): conn_str = "Provider=SQLNCLI;" else: conn_str = "Provider=SQLOLEDB;" conn_str += "Data Source=%s;Initial Catalog=%s;" # MSDE does not allow SQL server login if kw.get("sspi"): conn_str += \ "Integrated Security=SSPI;Persist Security Info=False" self.make_conn_str = lambda keys: conn_str % ( keys.host, keys.db) else: conn_str += "User Id=%s;Password=%s" self.make_conn_str = lambda keys: conn_str % ( keys.host, keys.db, keys.user, keys.password) kw.pop("sspi", None) kw.pop("ncli", None) else: # pymssql self.dbconnection = sqlmodule.connect sqlmodule.Binary = lambda st: str(st) # don't know whether pymssql uses unicode self.usingUnicodeStrings = False def _make_conn_str(keys): keys_dict = {} for attr, value in ( ('user', keys.user), ('password', keys.password), ('host', keys.host), ('port', keys.port), ('database', keys.db), ): if value: keys_dict[attr] = value return keys_dict self.make_conn_str = _make_conn_str self.autoCommit = int(autoCommit) self.user = user self.password = password self.host = host self.port = port self.db = db self._server_version = None self._can_use_max_types = None self._can_use_microseconds = None DBAPI.__init__(self, **kw) @classmethod def _connectionFromParams(cls, user, password, host, port, path, args): path = path.strip('/') return cls(user=user, password=password, host=host or 'localhost', port=port, db=path, **args) def insert_id(self, conn): """ insert_id method. """ c = conn.cursor() # converting the identity to an int is ugly, but it gets returned # as a decimal otherwise :S c.execute('SELECT CONVERT(INT, @@IDENTITY)') return c.fetchone()[0] def makeConnection(self): conn_descr = self.make_conn_str(self) if isinstance(conn_descr, dict): con = self.dbconnection(**conn_descr) else: con = self.dbconnection(conn_descr) cur = con.cursor() cur.execute('SET ANSI_NULLS ON') cur.execute("SELECT CAST('12345.21' AS DECIMAL(10, 2))") self.decimalSeparator = str(cur.fetchone()[0])[-3] cur.close() return con HAS_IDENTITY = """ select 1 from INFORMATION_SCHEMA.COLUMNS where TABLE_NAME = '%s' and COLUMNPROPERTY(object_id(TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1 """ def _hasIdentity(self, conn, table): query = self.HAS_IDENTITY % table c = conn.cursor() c.execute(query) r = c.fetchone() return r is not None def _queryInsertID(self, conn, soInstance, id, names, values): """ Insert the Initial with names and values, using id. """ table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName c = conn.cursor() has_identity = self._hasIdentity(conn, table) if id is not None: names = [idName] + names values = [id] + values elif has_identity and idName in names: try: i = names.index(idName) if i: del names[i] del values[i] except ValueError: pass if has_identity: if id is not None: c.execute('SET IDENTITY_INSERT %s ON' % table) else: c.execute('SET IDENTITY_INSERT %s OFF' % table) q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') c.execute(q) if has_identity: c.execute('SET IDENTITY_INSERT %s OFF' % table) if id is None: id = self.insert_id(conn) if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id @classmethod def _queryAddLimitOffset(cls, query, start, end): if end and not start: limit_str = "SELECT TOP %i" % end match = cls.limit_re.match(query) if match and len(match.groups()) == 2: return ' '.join([limit_str, match.group(2)]) else: return query def createReferenceConstraint(self, soClass, col): return col.mssqlCreateReferenceConstraint() def createColumn(self, soClass, col): return col.mssqlCreateSQL(self) def createIDColumn(self, soClass): key_type = {int: "INT", str: "TEXT"}[soClass.sqlmeta.idType] return '%s %s IDENTITY UNIQUE' % (soClass.sqlmeta.idName, key_type) def createIndexSQL(self, soClass, index): return index.mssqlCreateIndexSQL(soClass) def joinSQLType(self, join): return 'INT NOT NULL' SHOW_TABLES = "SELECT name FROM sysobjects WHERE type='U'" def tableExists(self, tableName): for (table,) in self.queryAll(self.SHOW_TABLES): if table.lower() == tableName.lower(): return True return False def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD %s' % (tableName, column.mssqlCreateSQL(self))) def delColumn(self, sqlmeta, column): self.query('ALTER TABLE %s DROP COLUMN %s' % (sqlmeta.table, column.dbName)) # Precision and scale is gotten from column table # so that we can create decimal columns if needed. SHOW_COLUMNS = """ select name, length, ( select name from systypes where cast(xusertype as int)= cast(sc.xtype as int) ) datatype, prec, scale, isnullable, cdefault, m.text default_text, isnull(len(autoval),0) is_identity from syscolumns sc LEFT OUTER JOIN syscomments m on sc.cdefault = m.id AND m.colid = 1 where sc.id in (select id from sysobjects where name = '%s') order by colorder""" def columnsFromSchema(self, tableName, soClass): colData = self.queryAll(self.SHOW_COLUMNS % tableName) results = [] for (field, size, t, precision, scale, nullAllowed, default, defaultText, is_identity) in colData: if field == soClass.sqlmeta.idName: continue # precision is needed for decimal columns colClass, kw = self.guessClass(t, size, precision, scale) kw['name'] = str(soClass.sqlmeta.style.dbColumnToPythonAttr(field)) kw['dbName'] = str(field) kw['notNone'] = not nullAllowed if (defaultText): # Strip ( and ) defaultText = defaultText[1:-1] if defaultText[0] == "'": defaultText = defaultText[1:-1] else: if t == "int": defaultText = int(defaultText) if t == "float": defaultText = float(defaultText) if t == "numeric": defaultText = float(defaultText) # TODO need to access the "column" to_python method here -- # but the object doesn't exists yet. # @@ skip key... kw['default'] = defaultText results.append(colClass(**kw)) return results def _setAutoCommit(self, conn, auto): # raise Exception(repr(auto)) return # conn.auto_commit = auto option = "ON" if auto == 0: option = "OFF" c = conn.cursor() c.execute("SET AUTOCOMMIT " + option) # from mx.ODBC.Windows import SQL # connection.setconnectoption( # SQL.AUTOCOMMIT, SQL.AUTOCOMMIT_ON if auto else SQL.AUTOCOMMIT_OFF) # precision and scale is needed for decimal columns def guessClass(self, t, size, precision, scale): """ Here we take raw values coming out of syscolumns and map to SQLObject class types. """ if t.startswith('int'): return col.IntCol, {} elif t.startswith('varchar'): if self.usingUnicodeStrings: return col.UnicodeCol, {'length': size} return col.StringCol, {'length': size} elif t.startswith('char'): if self.usingUnicodeStrings: return col.UnicodeCol, {'length': size, 'varchar': False} return col.StringCol, {'length': size, 'varchar': False} elif t.startswith('datetime'): return col.DateTimeCol, {} elif t.startswith('decimal'): # be careful for awkward naming return col.DecimalCol, {'size': precision, 'precision': scale} else: return col.Col, {} def server_version(self): """Get server version: 8 - 2000 9 - 2005 10 - 2008 11 - 2012 """ if self._server_version is not None: return self._server_version try: server_version = self.queryOne( "SELECT SERVERPROPERTY('productversion')")[0] server_version = server_version.split('.')[0] server_version = int(server_version) except: server_version = None # unknown self._server_version = server_version return server_version def can_use_max_types(self): if self._can_use_max_types is not None: return self._can_use_max_types server_version = self.server_version() self._can_use_max_types = can_use_max_types = \ (server_version is not None) and (server_version >= 9) return can_use_max_types def can_use_microseconds(self): if self._can_use_microseconds is not None: return self._can_use_microseconds server_version = self.server_version() self._can_use_microseconds = can_use_microseconds = \ (server_version is not None) and (server_version >= 10) return can_use_microseconds SQLObject-3.1.0/sqlobject/tests/0000755000175000017500000000000012754657361016021 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/tests/test_exceptions.py0000644000175000017500000000203012747416060021575 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject, StringCol from sqlobject.dberrors import DuplicateEntryError, ProgrammingError from sqlobject.tests.dbtest import getConnection, raises, setupClass, supports ######################################## # Table aliases and self-joins ######################################## class TestException(SQLObject): name = StringCol(unique=True, length=100) class TestExceptionWithNonexistingTable(SQLObject): pass def test_exceptions(): if not supports("exceptions"): py.test.skip("exceptions aren't supported") setupClass(TestException) TestException(name="test") raises(DuplicateEntryError, TestException, name="test") connection = getConnection() if connection.module.__name__ != 'psycopg2': return TestExceptionWithNonexistingTable.setConnection(connection) try: list(TestExceptionWithNonexistingTable.select()) except ProgrammingError as e: assert e.args[0].code == '42P01' else: assert False, "DID NOT RAISE" SQLObject-3.1.0/sqlobject/tests/test_empty.py0000644000175000017500000000100712747416060020555 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject from sqlobject.tests.dbtest import setupClass, supports class EmptyClass(SQLObject): pass def test_empty(): if not supports('emptyTable'): py.test.skip("emptyTable isn't supported") setupClass(EmptyClass) e1 = EmptyClass() e2 = EmptyClass() assert e1 != e2 assert e1.id != e2.id assert e1 in list(EmptyClass.select()) assert e2 in list(EmptyClass.select()) e1.destroySelf() assert list(EmptyClass.select()) == [e2] SQLObject-3.1.0/sqlobject/tests/test_transactions.py0000644000175000017500000000540612747416060022136 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject, SQLObjectNotFound, StringCol from sqlobject.tests.dbtest import raises, setupClass, supports ######################################## # Transaction test ######################################## class TestSOTrans(SQLObject): class sqlmeta: defaultOrder = 'name' name = StringCol(length=10, alternateID=True, dbName='name_col') def test_transaction(): if not supports('transactions'): py.test.skip("Transactions aren't supported") setupClass(TestSOTrans) TestSOTrans(name='bob') TestSOTrans(name='tim') trans = TestSOTrans._connection.transaction() try: TestSOTrans._connection.autoCommit = 'exception' TestSOTrans(name='joe', connection=trans) trans.rollback() trans.begin() assert ([n.name for n in TestSOTrans.select(connection=trans)] == ['bob', 'tim']) b = TestSOTrans.byName('bob', connection=trans) b.name = 'robert' trans.commit() assert b.name == 'robert' b.name = 'bob' trans.rollback() trans.begin() assert b.name == 'robert' finally: TestSOTrans._connection.autoCommit = True def test_transaction_commit_sync(): if not supports('transactions'): py.test.skip("Transactions aren't supported") setupClass(TestSOTrans) trans = TestSOTrans._connection.transaction() try: TestSOTrans(name='bob') bOut = TestSOTrans.byName('bob') bIn = TestSOTrans.byName('bob', connection=trans) bIn.name = 'robert' assert bOut.name == 'bob' trans.commit() assert bOut.name == 'robert' finally: TestSOTrans._connection.autoCommit = True def test_transaction_delete(close=False): if not supports('transactions'): py.test.skip("Transactions aren't supported") setupClass(TestSOTrans) connection = TestSOTrans._connection if (connection.dbName == 'sqlite') and connection._memory: py.test.skip("The following test requires a different connection") trans = connection.transaction() try: TestSOTrans(name='bob') bIn = TestSOTrans.byName('bob', connection=trans) bIn.destroySelf() bOut = TestSOTrans.select(TestSOTrans.q.name == 'bob') assert bOut.count() == 1 bOutInst = bOut[0] bOutID = bOutInst.id # noqa: bOutID is used in the string code below trans.commit(close=close) assert bOut.count() == 0 raises(SQLObjectNotFound, "TestSOTrans.get(bOutID)") raises(SQLObjectNotFound, "bOutInst.name") finally: trans.rollback() connection.autoCommit = True connection.close() def test_transaction_delete_with_close(): test_transaction_delete(close=True) SQLObject-3.1.0/sqlobject/tests/test_schema.py0000644000175000017500000000142512747416060020663 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject, UnicodeCol from sqlobject.tests.dbtest import getConnection, setupClass, supports ######################################## # Schema per connection ######################################## class TestSchema(SQLObject): foo = UnicodeCol(length=200) def test_connection_schema(): if not supports('schema'): py.test.skip("schemas aren't supported") conn = getConnection() conn.schema = None conn.query('CREATE SCHEMA test') conn.schema = 'test' conn.query('SET search_path TO test') setupClass(TestSchema) assert TestSchema._connection is conn TestSchema(foo='bar') assert conn.queryAll("SELECT * FROM test.test_schema") conn.schema = None conn.query('SET search_path TO public') SQLObject-3.1.0/sqlobject/tests/test_basic.py0000644000175000017500000002257612747416060020516 0ustar phdphd00000000000000import codecs import py.test from sqlobject import BoolCol, ForeignKey, IntCol, KeyCol, SQLObject, \ StringCol, connectionForURI, sqlhub from sqlobject.tests.dbtest import inserts, raises, setupClass, supports class TestSO1(SQLObject): name = StringCol(length=50, dbName='name_col') name.title = 'Your Name' name.foobar = 1 passwd = StringCol(length=10) class sqlmeta: cacheValues = False def _set_passwd(self, passwd): self._SO_set_passwd(codecs.encode(passwd, 'rot13')) def setupGetters(cls): setupClass(cls) inserts(cls, [('bob', 'god'), ('sally', 'sordid'), ('dave', 'dremel'), ('fred', 'forgo')], 'name passwd') def test_case1(): setupGetters(TestSO1) bob = TestSO1.selectBy(name='bob')[0] assert bob.name == 'bob' assert bob.passwd == codecs.encode('god', 'rot13') bobs = TestSO1.selectBy(name='bob')[:10] assert len(list(bobs)) == 1 def test_newline(): setupGetters(TestSO1) bob = TestSO1.selectBy(name='bob')[0] testString = 'hey\nyou\\can\'t you see me?\t' bob.name = testString bob.expire() assert bob.name == testString def test_count(): setupGetters(TestSO1) assert TestSO1.selectBy(name=None).count() == 0 assert TestSO1.selectBy(name='bob').count() == 1 assert TestSO1.select(TestSO1.q.name == 'bob').count() == 1 assert TestSO1.select().count() == len(list(TestSO1.select())) def test_getset(): setupGetters(TestSO1) bob = TestSO1.selectBy(name='bob')[0] assert bob.name == 'bob' bob.name = 'joe' assert bob.name == 'joe' bob.set(name='joebob', passwd='testtest') assert bob.name == 'joebob' def test_extra_vars(): setupGetters(TestSO1) col = TestSO1.sqlmeta.columns['name'] assert col.title == 'Your Name' assert col.foobar == 1 assert getattr(TestSO1.sqlmeta.columns['passwd'], 'title', None) is None class TestSO2(SQLObject): name = StringCol(length=50, dbName='name_col') passwd = StringCol(length=10) def _set_passwd(self, passwd): self._SO_set_passwd(codecs.encode(passwd, 'rot13')) def test_case2(): setupGetters(TestSO2) bob = TestSO2.selectBy(name='bob')[0] assert bob.name == 'bob' assert bob.passwd == codecs.encode('god', 'rot13') class Student(SQLObject): is_smart = BoolCol() def test_boolCol(): setupClass(Student) student = Student(is_smart=False) assert not student.is_smart student2 = Student(is_smart=1) assert student2.is_smart class TestSO3(SQLObject): name = StringCol(length=10, dbName='name_col') other = ForeignKey('TestSO4', default=None) other2 = KeyCol(foreignKey='TestSO4', default=None) class TestSO4(SQLObject): me = StringCol(length=10) def test_foreignKey(): setupClass([TestSO4, TestSO3]) test3_order = [col.name for col in TestSO3.sqlmeta.columnList] assert test3_order == ['name', 'otherID', 'other2ID'] tc3 = TestSO3(name='a') assert tc3.other is None assert tc3.other2 is None assert tc3.otherID is None assert tc3.other2ID is None tc4a = TestSO4(me='1') tc3.other = tc4a assert tc3.other == tc4a assert tc3.otherID == tc4a.id tc4b = TestSO4(me='2') tc3.other = tc4b.id assert tc3.other == tc4b assert tc3.otherID == tc4b.id tc4c = TestSO4(me='3') tc3.other2 = tc4c assert tc3.other2 == tc4c assert tc3.other2ID == tc4c.id tc4d = TestSO4(me='4') tc3.other2 = tc4d.id assert tc3.other2 == tc4d assert tc3.other2ID == tc4d.id tcc = TestSO3(name='b', other=tc4a) assert tcc.other == tc4a tcc2 = TestSO3(name='c', other=tc4a.id) assert tcc2.other == tc4a def test_selectBy(): setupClass([TestSO4, TestSO3]) tc4 = TestSO4(me='another') tc3 = TestSO3(name='sel', other=tc4) TestSO3(name='not joined') assert tc3.other == tc4 assert list(TestSO3.selectBy(other=tc4)) == [tc3] assert list(TestSO3.selectBy(otherID=tc4.id)) == [tc3] assert TestSO3.selectBy(otherID=tc4.id)[0] == tc3 assert list(TestSO3.selectBy(otherID=tc4.id)[:10]) == [tc3] assert list(TestSO3.selectBy(other=tc4)[:10]) == [tc3] class TestSO5(SQLObject): name = StringCol(length=10, dbName='name_col') other = ForeignKey('TestSO6', default=None, cascade=True) another = ForeignKey('TestSO7', default=None, cascade=True) class TestSO6(SQLObject): name = StringCol(length=10, dbName='name_col') other = ForeignKey('TestSO7', default=None, cascade=True) class TestSO7(SQLObject): name = StringCol(length=10, dbName='name_col') def test_foreignKeyDestroySelfCascade(): setupClass([TestSO7, TestSO6, TestSO5]) tc5 = TestSO5(name='a') tc6a = TestSO6(name='1') tc5.other = tc6a tc7a = TestSO7(name='2') tc6a.other = tc7a tc5.another = tc7a assert tc5.other == tc6a assert tc5.otherID == tc6a.id assert tc6a.other == tc7a assert tc6a.otherID == tc7a.id assert tc5.other.other == tc7a assert tc5.other.otherID == tc7a.id assert tc5.another == tc7a assert tc5.anotherID == tc7a.id assert tc5.other.other == tc5.another assert TestSO5.select().count() == 1 assert TestSO6.select().count() == 1 assert TestSO7.select().count() == 1 tc6b = TestSO6(name='3') tc6c = TestSO6(name='4') tc7b = TestSO7(name='5') tc6b.other = tc7b tc6c.other = tc7b assert TestSO5.select().count() == 1 assert TestSO6.select().count() == 3 assert TestSO7.select().count() == 2 tc6b.destroySelf() assert TestSO5.select().count() == 1 assert TestSO6.select().count() == 2 assert TestSO7.select().count() == 2 tc7b.destroySelf() assert TestSO5.select().count() == 1 assert TestSO6.select().count() == 1 assert TestSO7.select().count() == 1 tc7a.destroySelf() assert TestSO5.select().count() == 0 assert TestSO6.select().count() == 0 assert TestSO7.select().count() == 0 def testForeignKeyDropTableCascade(): if not supports('dropTableCascade'): py.test.skip("dropTableCascade isn't supported") setupClass(TestSO7) setupClass(TestSO6) setupClass(TestSO5) tc5a = TestSO5(name='a') tc6a = TestSO6(name='1') tc5a.other = tc6a tc7a = TestSO7(name='2') tc6a.other = tc7a tc5a.another = tc7a tc5b = TestSO5(name='b') tc5c = TestSO5(name='c') tc6b = TestSO6(name='3') tc5c.other = tc6b assert TestSO5.select().count() == 3 assert TestSO6.select().count() == 2 assert TestSO7.select().count() == 1 TestSO7.dropTable(cascade=True) assert TestSO5.select().count() == 3 assert TestSO6.select().count() == 2 tc6a.destroySelf() assert TestSO5.select().count() == 2 assert TestSO6.select().count() == 1 tc6b.destroySelf() assert TestSO5.select().count() == 1 assert TestSO6.select().count() == 0 assert next(iter(TestSO5.select())) == tc5b tc6c = TestSO6(name='3') tc5b.other = tc6c assert TestSO5.select().count() == 1 assert TestSO6.select().count() == 1 tc6c.destroySelf() assert TestSO5.select().count() == 0 assert TestSO6.select().count() == 0 class TestSO8(SQLObject): name = StringCol(length=10, dbName='name_col') other = ForeignKey('TestSO9', default=None, cascade=False) class TestSO9(SQLObject): name = StringCol(length=10, dbName='name_col') def testForeignKeyDestroySelfRestrict(): setupClass([TestSO9, TestSO8]) tc8a = TestSO8(name='a') tc9a = TestSO9(name='1') tc8a.other = tc9a tc8b = TestSO8(name='b') tc9b = TestSO9(name='2') assert tc8a.other == tc9a assert tc8a.otherID == tc9a.id assert TestSO8.select().count() == 2 assert TestSO9.select().count() == 2 raises(Exception, tc9a.destroySelf) tc9b.destroySelf() assert TestSO8.select().count() == 2 assert TestSO9.select().count() == 1 tc8a.destroySelf() tc8b.destroySelf() tc9a.destroySelf() assert TestSO8.select().count() == 0 assert TestSO9.select().count() == 0 class TestSO10(SQLObject): name = StringCol() class TestSO11(SQLObject): name = StringCol() other = ForeignKey('TestSO10', default=None, cascade='null') def testForeignKeySetNull(): setupClass([TestSO10, TestSO11]) obj1 = TestSO10(name='foo') obj2 = TestSO10(name='bar') dep1 = TestSO11(name='xxx', other=obj1) dep2 = TestSO11(name='yyy', other=obj1) dep3 = TestSO11(name='zzz', other=obj2) for name in 'xxx', 'yyy', 'zzz': assert len(list(TestSO11.selectBy(name=name))) == 1 obj1.destroySelf() for name in 'xxx', 'yyy', 'zzz': assert len(list(TestSO11.selectBy(name=name))) == 1 assert dep1.other is None assert dep2.other is None assert dep3.other is obj2 def testAsDict(): setupGetters(TestSO1) bob = TestSO1.selectBy(name='bob')[0] assert bob.sqlmeta.asDict() == { 'passwd': 'tbq', 'name': 'bob', 'id': bob.id} def test_nonexisting_attr(): setupClass(Student) raises(AttributeError, getattr, Student.q, 'nonexisting') class TestSO12(SQLObject): name = StringCol() value = IntCol(defaultSQL='1') def test_defaultSQL(): setupClass(TestSO12) test = TestSO12(name="test") assert test.value == 1 def test_connection_override(): sqlhub.processConnection = connectionForURI('sqlite:///db1') class TestSO13(SQLObject): _connection = connectionForURI('sqlite:///db2') assert TestSO13._connection.uri() == 'sqlite:///db2' del sqlhub.processConnection SQLObject-3.1.0/sqlobject/tests/test_reparent_sqlmeta.py0000644000175000017500000000161112747416060022766 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol, sqlmeta from sqlobject.tests.dbtest import setupClass real_sqlmeta = sqlmeta class Reparented1(SQLObject): class sqlmeta: table = 'reparented1' dummy = StringCol() class Reparented2(SQLObject): class sqlmeta(object): @classmethod def setClass(cls, soClass): # Well, it's pretty hard to call the superclass method # when it's a classmethod and it's not actually your # *current* superclass. Sigh real_sqlmeta.setClass.__func__(cls, soClass) cls.worked = True dummy = StringCol() def test_reparented(): setupClass([Reparented1, Reparented2]) assert Reparented1.sqlmeta.table == 'reparented1' assert issubclass(Reparented1.sqlmeta, real_sqlmeta) assert issubclass(Reparented2.sqlmeta, real_sqlmeta) assert Reparented2.sqlmeta.worked SQLObject-3.1.0/sqlobject/tests/test_aggregates.py0000644000175000017500000000417612747416060021542 0ustar phdphd00000000000000from sqlobject import FloatCol, IntCol, SQLObject from sqlobject.tests.dbtest import setupClass # Test MIN, AVG, MAX, COUNT, SUM class IntAccumulator(SQLObject): value = IntCol() class FloatAccumulator(SQLObject): value = FloatCol() def test_integer(): setupClass(IntAccumulator) IntAccumulator(value=1) IntAccumulator(value=2) IntAccumulator(value=3) assert IntAccumulator.select().min(IntAccumulator.q.value) == 1 assert IntAccumulator.select().avg(IntAccumulator.q.value) == 2 assert IntAccumulator.select().max(IntAccumulator.q.value) == 3 assert IntAccumulator.select().sum(IntAccumulator.q.value) == 6 assert IntAccumulator.select(IntAccumulator.q.value > 1).\ max(IntAccumulator.q.value) == 3 assert IntAccumulator.select(IntAccumulator.q.value > 1).\ sum(IntAccumulator.q.value) == 5 def floatcmp(f1, f2): if abs(f1 - f2) < 0.1: return 0 if f1 < f2: return 1 return -1 def test_float(): setupClass(FloatAccumulator) FloatAccumulator(value=1.2) FloatAccumulator(value=2.4) FloatAccumulator(value=3.8) assert floatcmp( FloatAccumulator.select().min(FloatAccumulator.q.value), 1.2) == 0 assert floatcmp( FloatAccumulator.select().avg(FloatAccumulator.q.value), 2.5) == 0 assert floatcmp( FloatAccumulator.select().max(FloatAccumulator.q.value), 3.8) == 0 assert floatcmp( FloatAccumulator.select().sum(FloatAccumulator.q.value), 7.4) == 0 def test_many(): setupClass(IntAccumulator) IntAccumulator(value=1) IntAccumulator(value=1) IntAccumulator(value=2) IntAccumulator(value=2) IntAccumulator(value=3) IntAccumulator(value=3) attribute = IntAccumulator.q.value assert IntAccumulator.select().accumulateMany( ("MIN", attribute), ("AVG", attribute), ("MAX", attribute), ("COUNT", attribute), ("SUM", attribute) ) == (1, 2, 3, 6, 12) assert IntAccumulator.select(distinct=True).accumulateMany( ("MIN", attribute), ("AVG", attribute), ("MAX", attribute), ("COUNT", attribute), ("SUM", attribute) ) == (1, 2, 3, 3, 6) SQLObject-3.1.0/sqlobject/tests/test_identity.py0000644000175000017500000000127212747416060021254 0ustar phdphd00000000000000from sqlobject import IntCol, SQLObject from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # Identity (MS SQL) ######################################## class TestIdentity(SQLObject): n = IntCol() def test_identity(): # (re)create table TestIdentity.dropTable(connection=getConnection(), ifExists=True) setupClass(TestIdentity) # insert without giving identity TestIdentity(n=100) # i1 # verify result i1get = TestIdentity.get(1) assert(i1get.n == 100) # insert while giving identity TestIdentity(id=2, n=200) # i2 # verify result i2get = TestIdentity.get(2) assert(i2get.n == 200) SQLObject-3.1.0/sqlobject/tests/__init__.py0000644000175000017500000000000210177633357020116 0ustar phdphd00000000000000# SQLObject-3.1.0/sqlobject/tests/test_jsoncol.py0000644000175000017500000000157512747417740021106 0ustar phdphd00000000000000from sqlobject import SQLObject, JSONCol from sqlobject.tests.dbtest import setupClass class JSONTest(SQLObject): json = JSONCol(default=None) _json_test_data = ( None, True, 1, 2.0, {u"test": [None, True, 1, 2.0, {u"unicode'with'apostrophes": u"unicode\"with\"quotes"}, [], u"unicode"]}, [None, True, 1, 2.0, [], {u"unicode'with'apostrophes": u"unicode\"with\"quotes"}, u"unicode", u"unicode'with'apostrophes", u"unicode\"with\"quotes", ], u"unicode", u"unicode'with'apostrophes", u"unicode\"with\"quotes", ) def test_JSONCol(): setupClass(JSONTest) for _id, test_data in enumerate(_json_test_data): json = JSONTest(id=_id + 1, json=test_data) JSONTest._connection.cache.clear() for _id, test_data in enumerate(_json_test_data): json = JSONTest.get(_id + 1) assert json.json == test_data SQLObject-3.1.0/sqlobject/tests/test_cache.py0000644000175000017500000000273612747416060020474 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.cache import CacheSet from .dbtest import setupClass class Something(object): pass def test_purge1(): x = CacheSet() y = Something() obj = x.get(1, y.__class__) assert obj is None x.put(1, y.__class__, y) x.finishPut(y.__class__) j = x.get(1, y.__class__) assert j == y x.expire(1, y.__class__) j = x.get(1, y.__class__) assert j is None x.finishPut(y.__class__) j = x.get(1, y.__class__) assert j is None x.finishPut(y.__class__) class CacheTest(SQLObject): name = StringCol(alternateID=True, length=100) def test_cache(): setupClass(CacheTest) s = CacheTest(name='foo') obj_id = id(s) s_id = s.id assert CacheTest.get(s_id) is s assert not s.sqlmeta.expired CacheTest.sqlmeta.expireAll() assert s.sqlmeta.expired CacheTest.sqlmeta.expireAll() s1 = CacheTest.get(s_id) # We should have a new object: assert id(s1) != obj_id obj_id2 = id(s1) CacheTest._connection.expireAll() s2 = CacheTest.get(s_id) assert id(s2) != obj_id and id(s2) != obj_id2 def test_cache_cull(): setupClass(CacheTest) s = CacheTest(name='test_cache_create') for count in range(s._connection.cache.caches['CacheTest'].cullFrequency): CacheTest(name='test_cache_create %d' % count) assert len(s._connection.cache.caches['CacheTest'].cache) < \ s._connection.cache.caches['CacheTest'].cullFrequency SQLObject-3.1.0/sqlobject/tests/test_validation.py0000644000175000017500000000703712747416060021562 0ustar phdphd00000000000000from sqlobject import BoolCol, FloatCol, IntCol, PickleCol, SQLObject, \ StringCol, UnicodeCol from sqlobject.col import validators from sqlobject.compat import PY2 from sqlobject.tests.dbtest import raises, setupClass if not PY2: # alias for python 3 compatability long = int ######################################## # Validation/conversion ######################################## class SOTestValidator(validators.Validator): def to_python(self, value, state): if value: self.save_value.append(value) return 1 return value def from_python(self, value, state): if value: self.save_value.append(value) return 2 return value validator1 = SOTestValidator(save_value=[]) validator2 = SOTestValidator(save_value=[]) class SOValidation(SQLObject): name = StringCol(validator=validators.PlainText(), default='x', dbName='name_col') name2 = StringCol(validator=validators.ConfirmType(type=str), default='y') name3 = IntCol(validator=validators.Wrapper(fromPython=int), default=100) name4 = FloatCol(default=2.718) name5 = PickleCol(default=None) name6 = BoolCol(default=None) name7 = UnicodeCol(default=None) name8 = IntCol(default=None) name9 = IntCol(validator=validator1, validator2=validator2, default=0) class SOValidationTest(object): def __init__(self, value): self.value = value if PY2: class SOValidationTestUnicode(SOValidationTest): def __unicode__(self): return self.value class SOValidationTestInt(SOValidationTest): def __int__(self): return self.value class SOValidationTestBool(SOValidationTest): def __nonzero__(self): return self.value class SOValidationTestFloat(SOValidationTest): def __float__(self): return self.value class TestValidation: def setup_method(self, meth): setupClass(SOValidation) def test_validate(self): t = SOValidation(name='hey') raises(validators.Invalid, setattr, t, 'name', '!!!') t.name = 'you' assert t.name == 'you' def test_confirmType(self): t = SOValidation(name2='hey') raises(validators.Invalid, setattr, t, 'name2', 1) raises(validators.Invalid, setattr, t, 'name3', '1') raises(validators.Invalid, setattr, t, 'name4', '1') raises(validators.Invalid, setattr, t, 'name6', '1') raises(validators.Invalid, setattr, t, 'name7', 1) t.name2 = 'you' assert t.name2 == 'you' for name, cls, value in ( ('name4', SOValidationTestFloat, 1.1), ('name6', SOValidationTestBool, True), ('name8', SOValidationTestInt, 1)): setattr(t, name, cls(value)) assert getattr(t, name) == value if PY2: for name, cls, value in ( ('name7', SOValidationTestUnicode, u'test'),): setattr(t, name, cls(value)) assert getattr(t, name) == value def test_wrapType(self): t = SOValidation(name3=1) raises(validators.Invalid, setattr, t, 'name3', 'x') t.name3 = long(1) assert t.name3 == 1 t.name3 = 0 assert t.name3 == 0 def test_emptyValue(self): t = SOValidation(name5={}) assert t.name5 == {} def test_validator2(self): SOValidation(name9=1) SOValidation(name9=2) assert validator1.save_value == [2, 2, 2, 2, 2, 2] assert validator2.save_value == [1, 1, 1, 2, 1, 1] SQLObject-3.1.0/sqlobject/tests/test_md5.py0000644000175000017500000000065612465376600020117 0ustar phdphd00000000000000from hashlib import md5 ######################################## # hashlib.md5 ######################################## def test_md5(): assert md5(b'').hexdigest() == 'd41d8cd98f00b204e9800998ecf8427e' assert md5(b'\n').hexdigest() == '68b329da9893e34099c7d8ad5cb9c940' assert md5(b'123').hexdigest() == '202cb962ac59075b964b07152d234b70' assert md5(b'123\n').hexdigest() == 'ba1f2511fc30423bdbb183fe33f3dd0f' SQLObject-3.1.0/sqlobject/tests/test_comparison.py0000644000175000017500000000076712747416060021605 0ustar phdphd00000000000000from sqlobject import SQLObject from sqlobject.tests.dbtest import setupClass class TestComparison(SQLObject): pass def test_eq(): setupClass(TestComparison, force=True) t1 = TestComparison() t2 = TestComparison() TestComparison._connection.cache.clear() t3 = TestComparison.get(1) t4 = TestComparison.get(2) assert t1.id == t3.id assert t2.id == t4.id assert t1 is not t3 assert t2 is not t4 assert t1 == t3 assert t2 == t4 assert t1 != t2 SQLObject-3.1.0/sqlobject/tests/test_cyclic_reference.py0000644000175000017500000000404112747416060022704 0ustar phdphd00000000000000import py.test from sqlobject import BLOBCol, DateTimeCol, ForeignKey, IntCol, SQLObject, \ StringCol, sqlmeta from sqlobject.tests.dbtest import getConnection, supports class TestCyclicReferenceA(SQLObject): class sqlmeta(sqlmeta): idName = 'test_id_here' table = 'test_cyclic_reference_a_table' name = StringCol() number = IntCol() time = DateTimeCol() short = StringCol(length=10) blobcol = BLOBCol() fkeyb = ForeignKey('TestCyclicReferenceB') class TestCyclicReferenceB(SQLObject): class sqlmeta(sqlmeta): idName = 'test_id_here' table = 'test_cyclic_reference_b_table' name = StringCol() number = IntCol() time = DateTimeCol() short = StringCol(length=10) blobcol = BLOBCol() fkeya = ForeignKey('TestCyclicReferenceA') def test_cyclic_reference(): if not supports('dropTableCascade'): py.test.skip("dropTableCascade isn't supported") conn = getConnection() TestCyclicReferenceA.setConnection(conn) TestCyclicReferenceB.setConnection(conn) TestCyclicReferenceA.dropTable(ifExists=True, cascade=True) assert not conn.tableExists(TestCyclicReferenceA.sqlmeta.table) TestCyclicReferenceB.dropTable(ifExists=True, cascade=True) assert not conn.tableExists(TestCyclicReferenceB.sqlmeta.table) constraints = TestCyclicReferenceA.createTable(ifNotExists=True, applyConstraints=False) assert conn.tableExists(TestCyclicReferenceA.sqlmeta.table) constraints += TestCyclicReferenceB.createTable(ifNotExists=True, applyConstraints=False) assert conn.tableExists(TestCyclicReferenceB.sqlmeta.table) for constraint in constraints: conn.query(constraint) TestCyclicReferenceA.dropTable(ifExists=True, cascade=True) assert not conn.tableExists(TestCyclicReferenceA.sqlmeta.table) TestCyclicReferenceB.dropTable(ifExists=True, cascade=True) assert not conn.tableExists(TestCyclicReferenceB.sqlmeta.table) SQLObject-3.1.0/sqlobject/tests/test_views.py0000644000175000017500000001262712747416060020566 0ustar phdphd00000000000000from sqlobject import ForeignKey, IntCol, SQLMultipleJoin, SQLObject, \ StringCol, func from sqlobject.views import ViewSQLObject from sqlobject.tests.dbtest import inserts, setupClass class PhoneNumber(SQLObject): number = StringCol() calls = SQLMultipleJoin('PhoneCall') incoming = SQLMultipleJoin('PhoneCall', joinColumn='toID') class PhoneCall(SQLObject): phoneNumber = ForeignKey('PhoneNumber') to = ForeignKey('PhoneNumber') minutes = IntCol() class ViewPhoneCall(ViewSQLObject): class sqlmeta: idName = PhoneCall.q.id clause = PhoneCall.q.phoneNumberID == PhoneNumber.q.id minutes = IntCol(dbName=PhoneCall.q.minutes) number = StringCol(dbName=PhoneNumber.q.number) phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id) call = ForeignKey('PhoneCall', dbName=PhoneCall.q.id) class ViewPhone(ViewSQLObject): class sqlmeta: idName = PhoneNumber.q.id clause = PhoneCall.q.phoneNumberID == PhoneNumber.q.id minutes = IntCol(dbName=func.SUM(PhoneCall.q.minutes)) numberOfCalls = IntCol(dbName=func.COUNT(PhoneCall.q.phoneNumberID)) number = StringCol(dbName=PhoneNumber.q.number) phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id) calls = SQLMultipleJoin('PhoneCall', joinColumn='phoneNumberID') vCalls = SQLMultipleJoin('ViewPhoneCall', joinColumn='phoneNumberID', orderBy='id') class ViewPhoneMore(ViewSQLObject): ''' View on top of view ''' class sqlmeta: idName = ViewPhone.q.id clause = ViewPhone.q.id == PhoneCall.q.toID number = StringCol(dbName=ViewPhone.q.number) timesCalled = IntCol(dbName=func.COUNT(PhoneCall.q.toID)) timesCalledLong = IntCol(dbName=func.COUNT(PhoneCall.q.toID)) timesCalledLong.aggregateClause = PhoneCall.q.minutes > 10 minutesCalled = IntCol(dbName=func.SUM(PhoneCall.q.minutes)) class ViewPhoneMore2(ViewPhoneMore): class sqlmeta: table = 'vpm' class ViewPhoneInnerAggregate(ViewPhone): twiceMinutes = IntCol(dbName=func.SUM(PhoneCall.q.minutes) * 2) def setup_module(mod): global calls, phones, sqlrepr setupClass([PhoneNumber, PhoneCall]) ViewPhoneCall._connection = PhoneNumber._connection ViewPhone._connection = PhoneNumber._connection ViewPhoneMore._connection = PhoneNumber._connection phones = inserts(PhoneNumber, [('1234567890',), ('1111111111',)], 'number') calls = inserts(PhoneCall, [(phones[0], phones[1], 5), (phones[0], phones[1], 20), (phones[1], phones[0], 10), (phones[1], phones[0], 25)], 'phoneNumber to minutes') sqlrepr = PhoneNumber._connection.sqlrepr def testSimpleVPC(): assert hasattr(ViewPhoneCall, 'minutes') assert hasattr(ViewPhoneCall, 'number') assert hasattr(ViewPhoneCall, 'phoneNumberID') def testColumnSQLVPC(): assert str(sqlrepr(ViewPhoneCall.q.id)) == 'view_phone_call.id' assert str(sqlrepr(ViewPhoneCall.q.minutes)) == 'view_phone_call.minutes' q = sqlrepr(ViewPhoneCall.q) assert q.count('phone_call.minutes AS minutes') assert q.count('phone_number.number AS number') def testAliasOverride(): assert str(sqlrepr(ViewPhoneMore2.q.id)) == 'vpm.id' def checkAttr(cls, id, attr, value): assert getattr(cls.get(id), attr) == value def testGetVPC(): checkAttr(ViewPhoneCall, calls[0].id, 'number', calls[0].phoneNumber.number) checkAttr(ViewPhoneCall, calls[0].id, 'minutes', calls[0].minutes) checkAttr(ViewPhoneCall, calls[0].id, 'phoneNumber', calls[0].phoneNumber) checkAttr(ViewPhoneCall, calls[2].id, 'number', calls[2].phoneNumber.number) checkAttr(ViewPhoneCall, calls[2].id, 'minutes', calls[2].minutes) checkAttr(ViewPhoneCall, calls[2].id, 'phoneNumber', calls[2].phoneNumber) def testGetVP(): checkAttr(ViewPhone, phones[0].id, 'number', phones[0].number) checkAttr(ViewPhone, phones[0].id, 'minutes', phones[0].calls.sum(PhoneCall.q.minutes)) checkAttr(ViewPhone, phones[0].id, 'phoneNumber', phones[0]) def testGetVPM(): checkAttr(ViewPhoneMore, phones[0].id, 'number', phones[0].number) checkAttr(ViewPhoneMore, phones[0].id, 'minutesCalled', phones[0].incoming.sum(PhoneCall.q.minutes)) checkAttr(ViewPhoneMore, phones[0].id, 'timesCalled', phones[0].incoming.count()) checkAttr(ViewPhoneMore, phones[0].id, 'timesCalledLong', phones[0].incoming.filter(PhoneCall.q.minutes > 10).count()) def testJoinView(): p = ViewPhone.get(phones[0].id) assert p.calls.count() == 2 assert p.vCalls.count() == 2 assert p.vCalls[0] == ViewPhoneCall.get(calls[0].id) def testInnerAggregate(): checkAttr(ViewPhoneInnerAggregate, phones[0].id, 'twiceMinutes', phones[0].calls.sum(PhoneCall.q.minutes) * 2) def testSelect(): s = ViewPhone.select() assert s.count() == len(phones) s = ViewPhoneCall.select() assert s.count() == len(calls) def testSelect2(): s = ViewPhone.select(ViewPhone.q.number == phones[0].number) assert s.getOne().phoneNumber == phones[0] def testDistinctCount(): # This test is for SelectResults non-* based count when distinct # We're really just checking this doesn't raise anything # due to lack of sqlrepr'ing. assert ViewPhone.select(distinct=True).count() == 2 SQLObject-3.1.0/sqlobject/tests/test_class_hash.py0000644000175000017500000000102412747416060021526 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import setupClass ######################################## # Test hashing a column instance ######################################## class ClassHashTest(SQLObject): name = StringCol(length=50, alternateID=True, dbName='name_col') def test_class_hash(): setupClass(ClassHashTest) ClassHashTest(name='bob') b = ClassHashTest.byName('bob') hashed = hash(b) b.expire() b = ClassHashTest.byName('bob') assert hash(b) == hashed SQLObject-3.1.0/sqlobject/tests/test_columns_order.py0000644000175000017500000000067412747416060022303 0ustar phdphd00000000000000from sqlobject import IntCol, SQLObject, StringCol ######################################## # Columns order ######################################## class SOColumnsOrder(SQLObject): name = StringCol() surname = StringCol() parname = StringCol() age = IntCol() def test_columns_order(): column_names = [c.name for c in SOColumnsOrder.sqlmeta.columnList] assert column_names == ['name', 'surname', 'parname', 'age'] SQLObject-3.1.0/sqlobject/tests/test_enum.py0000644000175000017500000000277712747416060020402 0ustar phdphd00000000000000from sqlobject import EnumCol, SQLObject, UnicodeCol from sqlobject.col import validators from sqlobject.tests.dbtest import raises, setupClass ######################################## # Enum test ######################################## class Enum1(SQLObject): l = EnumCol(enumValues=['a', 'bcd', 'e']) def testBad(): setupClass(Enum1) for l in ['a', 'bcd', 'a', 'e']: Enum1(l=l) raises( (Enum1._connection.module.IntegrityError, Enum1._connection.module.ProgrammingError, validators.Invalid), Enum1, l='b') class EnumWithNone(SQLObject): l = EnumCol(enumValues=['a', 'bcd', 'e', None]) def testNone(): setupClass(EnumWithNone) for l in [None, 'a', 'bcd', 'a', 'e', None]: e = EnumWithNone(l=l) assert e.l == l class EnumWithDefaultNone(SQLObject): l = EnumCol(enumValues=['a', 'bcd', 'e', None], default=None) def testDefaultNone(): setupClass(EnumWithDefaultNone) e = EnumWithDefaultNone() assert e.l is None class EnumWithDefaultOther(SQLObject): l = EnumCol(enumValues=['a', 'bcd', 'e', None], default='a') def testDefaultOther(): setupClass(EnumWithDefaultOther) e = EnumWithDefaultOther() assert e.l == 'a' class EnumUnicode(SQLObject): n = UnicodeCol() l = EnumCol(enumValues=['a', 'b']) def testUnicode(): setupClass(EnumUnicode) EnumUnicode(n=u'a', l='a') EnumUnicode(n=u'b', l=u'b') EnumUnicode(n=u'\u201c', l='a') EnumUnicode(n=u'\u201c', l=u'b') SQLObject-3.1.0/sqlobject/tests/test_ForeignKey.py0000644000175000017500000000747412747416060021477 0ustar phdphd00000000000000from formencode import validators from sqlobject import ForeignKey, IntCol, SQLObject, StringCol from sqlobject.tests.dbtest import getConnection, InstalledTestDatabase, \ raises, setupClass, setupCyclicClasses class TestComposerKey(SQLObject): name = StringCol() id2 = IntCol(default=None, unique=True) class TestWorkKey(SQLObject): class sqlmeta: idName = "work_id" composer = ForeignKey('TestComposerKey', cascade=True) title = StringCol() class TestWorkKey2(SQLObject): title = StringCol() class TestOtherColumn(SQLObject): key1 = ForeignKey('TestComposerKey', default=None) key2 = ForeignKey('TestComposerKey', refColumn='id2', default=None) def test1(): setupClass([TestComposerKey, TestWorkKey]) c = TestComposerKey(name='Mahler, Gustav') w1 = TestWorkKey(composer=c, title='Symphony No. 9') w2 = TestWorkKey(composer=None, title=None) # Select by usual way s = TestWorkKey.selectBy(composerID=c.id, title='Symphony No. 9') assert s.count() == 1 assert s[0] == w1 # selectBy object.id s = TestWorkKey.selectBy(composer=c.id, title='Symphony No. 9') assert s.count() == 1 assert s[0] == w1 # selectBy object s = TestWorkKey.selectBy(composer=c, title='Symphony No. 9') assert s.count() == 1 assert s[0] == w1 # selectBy id s = TestWorkKey.selectBy(id=w1.id) assert s.count() == 1 assert s[0] == w1 # is None handled correctly? s = TestWorkKey.selectBy(composer=None, title=None) assert s.count() == 1 assert s[0] == w2 s = TestWorkKey.selectBy() assert s.count() == 2 # select with objects s = TestWorkKey.select(TestWorkKey.q.composerID == c.id) assert s.count() == 1 assert s[0] == w1 s = TestWorkKey.select(TestWorkKey.q.composer == c.id) assert s.count() == 1 assert s[0] == w1 s = TestWorkKey.select(TestWorkKey.q.composerID == c) assert s.count() == 1 assert s[0] == w1 s = TestWorkKey.select(TestWorkKey.q.composer == c) assert s.count() == 1 assert s[0] == w1 s = TestWorkKey.select( (TestWorkKey.q.composer == c) & (TestWorkKey.q.title == 'Symphony No. 9')) assert s.count() == 1 assert s[0] == w1 def test2(): TestWorkKey._connection = getConnection() InstalledTestDatabase.drop(TestWorkKey) setupClass([TestComposerKey, TestWorkKey2], force=True) TestWorkKey2.sqlmeta.addColumn(ForeignKey('TestComposerKey'), changeSchema=True) def test_otherColumn(): setupClass([TestComposerKey, TestOtherColumn]) test_composer1 = TestComposerKey(name='Test1') test_composer2 = TestComposerKey(name='Test2', id2=2) test_fkey = TestOtherColumn(key1=test_composer1) test_other = TestOtherColumn(key2=test_composer2.id2) getConnection().cache.clear() assert test_fkey.key1 == test_composer1 assert test_other.key2 == test_composer2 class TestFKValidationA(SQLObject): name = StringCol() bfk = ForeignKey("TestFKValidationB") cfk = ForeignKey("TestFKValidationC", default=None) class TestFKValidationB(SQLObject): name = StringCol() afk = ForeignKey("TestFKValidationA") class TestFKValidationC(SQLObject): class sqlmeta: idType = str name = StringCol() def test_foreignkey_validation(): setupCyclicClasses(TestFKValidationA, TestFKValidationB, TestFKValidationC) a = TestFKValidationA(name="testa", bfk=None) b = TestFKValidationB(name="testb", afk=a) c = TestFKValidationC(id='testc', name="testc") a.bfk = b a.cfk = c assert a.bfk == b assert a.cfk == c assert b.afk == a raises(validators.Invalid, TestFKValidationA, name="testa", bfk='testb', cfk='testc') a = TestFKValidationA(name="testa", bfk=1, cfk='testc') assert a.bfkID == 1 assert a.cfkID == 'testc' SQLObject-3.1.0/sqlobject/tests/test_sqlbuilder_dbspecific.py0000644000175000017500000000364712747416060023754 0ustar phdphd00000000000000from __future__ import print_function from sqlobject import BoolCol, SQLObject from sqlobject.sqlbuilder import AND, Alias, EXISTS, JOIN, LEFTJOINOn, \ Select, sqlrepr from sqlobject.tests.dbtest import setupClass ''' Going to test that complex sqlbuilder constructions are never prematurely stringified. A straight-forward approach is to use Bools, since postgresql wants special formatting in queries. The test is whether a call to sqlrepr(x, 'postgres') includes the appropriate bool formatting throughout. ''' class SBButton(SQLObject): activated = BoolCol() def makeClause(): # It's not a comparison, it's an SQLExpression return SBButton.q.activated == True # noqa def makeSelect(): return Select(SBButton.q.id, clause=makeClause()) def checkCount(q, c, msg=''): print("STRING:", str(q)) print("POSTGR:", sqlrepr(q, 'postgres')) assert sqlrepr(q, 'postgres').count("'t'") == c and \ sqlrepr(q, 'postgres') != str(q), msg def testSimple(): setupClass(SBButton) yield checkCount, makeClause(), 1 yield checkCount, makeSelect(), 1 def testMiscOps(): setupClass(SBButton) yield checkCount, AND(makeClause(), makeClause()), 2 yield checkCount, AND(makeClause(), EXISTS(makeSelect())), 2 def testAliased(): setupClass(SBButton) b = Alias(makeSelect(), 'b') yield checkCount, b, 1 yield checkCount, Select(b.q.id), 1 # Table1 & Table2 are treated individually in joins yield checkCount, JOIN(None, b), 1 yield checkCount, JOIN(b, SBButton), 1 yield checkCount, JOIN(SBButton, b), 1 yield checkCount, LEFTJOINOn(None, b, SBButton.q.id == b.q.id), 1 yield checkCount, LEFTJOINOn(b, SBButton, SBButton.q.id == b.q.id), 1 yield checkCount, LEFTJOINOn(SBButton, b, SBButton.q.id == b.q.id), 1 def testTablesUsedSResults(): setupClass(SBButton) yield checkCount, SBButton.select(makeClause()).queryForSelect(), 1 SQLObject-3.1.0/sqlobject/tests/test_string_id.py0000644000175000017500000000312712747416060021406 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol, sqlmeta from sqlobject.tests.dbtest import setupClass ######################################## # String ID test ######################################## class SOStringID(SQLObject): class sqlmeta(sqlmeta): table = 'so_string_id' idType = str val = StringCol(alternateID=True) mysqlCreate = """ CREATE TABLE IF NOT EXISTS so_string_id ( id VARCHAR(50) PRIMARY KEY, val TEXT ) """ postgresCreate = """ CREATE TABLE so_string_id ( id VARCHAR(50) PRIMARY KEY, val TEXT ) """ sybaseCreate = """ CREATE TABLE so_string_id ( id VARCHAR(50) UNIQUE, val VARCHAR(50) NULL ) """ firebirdCreate = """ CREATE TABLE so_string_id ( id VARCHAR(50) NOT NULL PRIMARY KEY, val BLOB SUB_TYPE TEXT ) """ mssqlCreate = """ CREATE TABLE so_string_id ( id VARCHAR(50) PRIMARY KEY, val varchar(4000) ) """ sqliteCreate = postgresCreate mysqlDrop = """ DROP TABLE IF EXISTS so_string_id """ postgresDrop = """ DROP TABLE so_string_id """ sqliteDrop = postgresDrop firebirdDrop = postgresDrop mssqlDrop = postgresDrop def test_stringID(): setupClass(SOStringID) t1 = SOStringID(id='hey', val='whatever') t2 = SOStringID.byVal('whatever') assert t1 == t2 assert t1.val == t2.val assert t1.val == 'whatever' t1 = SOStringID(id='you', val='nowhere') t2 = SOStringID.get('you') assert t1 == t2 assert t1.val == t2.val assert t1.val == 'nowhere' SQLObject-3.1.0/sqlobject/tests/test_sqlbuilder.py0000644000175000017500000001004712747416060021571 0ustar phdphd00000000000000from sqlobject import IntCol, SQLObject, StringCol from sqlobject.compat import PY2 from sqlobject.sqlbuilder import AND, CONCAT, Delete, Insert, SQLOp, Select, \ Union, Update, const, func, sqlrepr from sqlobject.tests.dbtest import getConnection, raises, setupClass class TestSQLBuilder(SQLObject): name = StringCol() value = IntCol() def test_Select(): setupClass(TestSQLBuilder) select1 = Select([const.id, func.MAX(const.salary)], staticTables=['employees']) assert sqlrepr(select1) == 'SELECT id, MAX(salary) FROM employees' select2 = Select([TestSQLBuilder.q.name, TestSQLBuilder.q.value]) assert sqlrepr(select2) == \ 'SELECT test_sql_builder.name, test_sql_builder.value ' \ 'FROM test_sql_builder' union = Union(select1, select2) assert sqlrepr(union) == \ 'SELECT id, MAX(salary) FROM employees ' \ 'UNION SELECT test_sql_builder.name, test_sql_builder.value ' \ 'FROM test_sql_builder' union = Union(TestSQLBuilder.select().queryForSelect()) assert sqlrepr(union) == \ 'SELECT test_sql_builder.id, test_sql_builder.name, ' \ 'test_sql_builder.value FROM test_sql_builder WHERE 1 = 1' def test_empty_AND(): assert AND() is None assert AND(True) is True # sqlrepr() is needed because AND() returns an SQLExpression that overrides # comparison. The following # AND('x', 'y') == "foo bar" # is True! (-: Eeek! assert sqlrepr(AND(1, 2)) == sqlrepr(SQLOp("AND", 1, 2)) == "((1) AND (2))" assert sqlrepr(AND(1, 2, '3'), "sqlite") == \ sqlrepr(SQLOp("AND", 1, SQLOp("AND", 2, '3')), "sqlite") == \ "((1) AND ((2) AND ('3')))" def test_modulo(): setupClass(TestSQLBuilder) assert sqlrepr(TestSQLBuilder.q.value % 2 == 0, 'mysql') == \ "((MOD(test_sql_builder.value, 2)) = (0))" assert sqlrepr(TestSQLBuilder.q.value % 2 == 0, 'sqlite') == \ "(((test_sql_builder.value) % (2)) = (0))" def test_str_or_sqlrepr(): select = Select(['id', 'name'], staticTables=['employees'], where='value>0', orderBy='id') assert sqlrepr(select, 'sqlite') == \ 'SELECT id, name FROM employees WHERE value>0 ORDER BY id' select = Select(['id', 'name'], staticTables=['employees'], where='value>0', orderBy='id', lazyColumns=True) assert sqlrepr(select, 'sqlite') == \ 'SELECT id FROM employees WHERE value>0 ORDER BY id' insert = Insert('employees', values={'id': 1, 'name': 'test'}) assert sqlrepr(insert, 'sqlite') == \ "INSERT INTO employees (id, name) VALUES (1, 'test')" update = Update('employees', {'name': 'test'}, where='id=1') assert sqlrepr(update, 'sqlite') == \ "UPDATE employees SET name='test' WHERE id=1" update = Update('employees', {'name': 'test', 'age': 42}, where='id=1') assert sqlrepr(update, 'sqlite') == \ "UPDATE employees SET age=42, name='test' WHERE id=1" delete = Delete('employees', where='id=1') assert sqlrepr(delete, 'sqlite') == \ "DELETE FROM employees WHERE id=1" raises(TypeError, Delete, 'employees') delete = Delete('employees', where=None) assert sqlrepr(delete, 'sqlite') == \ "DELETE FROM employees" def test_CONCAT(): setupClass(TestSQLBuilder) TestSQLBuilder(name='test', value=42) assert sqlrepr(CONCAT('a', 'b'), 'mysql') == "CONCAT('a', 'b')" assert sqlrepr(CONCAT('a', 'b'), 'sqlite') == "'a' || 'b'" assert sqlrepr(CONCAT('prefix', TestSQLBuilder.q.name), 'mysql') == \ "CONCAT('prefix', test_sql_builder.name)" assert sqlrepr(CONCAT('prefix', TestSQLBuilder.q.name), 'sqlite') == \ "'prefix' || test_sql_builder.name" select = Select([CONCAT(TestSQLBuilder.q.name, '-suffix')], staticTables=['test_sql_builder']) connection = getConnection() rows = connection.queryAll(connection.sqlrepr(select)) result = rows[0][0] if not PY2 and not isinstance(result, str): result = result.decode('ascii') assert result == "test-suffix" SQLObject-3.1.0/sqlobject/tests/test_slice.py0000644000175000017500000000303612747416060020522 0ustar phdphd00000000000000import py.test from sqlobject import IntCol, SQLObject from sqlobject.tests.dbtest import setupClass, supports ######################################## # Slicing tests ######################################## def listrange(*args): """Always return a list, for py3k compatibility""" return list(range(*args)) class Counter(SQLObject): number = IntCol(notNull=True) class TestSlice: def setup_method(self, meth): setupClass(Counter) for i in range(100): Counter(number=i) def counterEqual(self, counters, value): if not supports('limitSelect'): py.test.skip("limitSelect isn't supported") assert [c.number for c in counters] == value def test_slice(self): self.counterEqual( Counter.select(None, orderBy='number'), listrange(100)) self.counterEqual( Counter.select(None, orderBy='number')[10:20], listrange(10, 20)) self.counterEqual( Counter.select(None, orderBy='number')[20:30][:5], listrange(20, 25)) self.counterEqual( Counter.select(None, orderBy='number')[20:30][1:5], listrange(21, 25)) self.counterEqual( Counter.select(None, orderBy='number')[:-10], listrange(0, 90)) self.counterEqual( Counter.select(None, orderBy='number', reversed=True), listrange(99, -1, -1)) self.counterEqual( Counter.select(None, orderBy='-number'), listrange(99, -1, -1)) SQLObject-3.1.0/sqlobject/tests/test_parse_uri.py0000644000175000017500000001170212467122324021407 0ustar phdphd00000000000000import os from sqlobject.dbconnection import DBConnection from sqlobject.sqlite.sqliteconnection import SQLiteConnection ######################################## # Test _parseURI ######################################## def test_parse(): _parseURI = DBConnection._parseURI user, password, host, port, path, args = _parseURI("mysql://host/database") assert user is None assert password is None assert host == "host" assert port is None assert path == "/database" assert args == {} user, password, host, port, path, args = _parseURI( "mysql://user:pass%20word@host/database?unix_socket=/var/mysql/socket") assert user == "user" assert password == "pass word" assert host == "host" assert port is None assert path == "/database" assert args == {"unix_socket": "/var/mysql/socket"} user, password, host, port, path, args = \ _parseURI("postgres://user@host/database") assert user == "user" assert password is None assert host == "host" assert port is None assert path == "/database" assert args == {} user, password, host, port, path, args = \ _parseURI("postgres://host:5432/database") assert user is None assert password is None assert host == "host" assert port == 5432 assert path == "/database" assert args == {} user, password, host, port, path, args = \ _parseURI("postgres:///full/path/to/socket/database") assert user is None assert password is None assert host is None assert port is None assert path == "/full/path/to/socket/database" assert args == {} user, password, host, port, path, args = \ _parseURI("postgres://us%3Aer:p%40ssword@host/database") assert user == "us:er" assert password == "p@ssword" assert host == "host" assert port is None assert path == "/database" assert args == {} user, password, host, port, path, args = \ _parseURI("sqlite:///full/path/to/database") assert user is None assert password is None assert host is None assert port is None assert path == "/full/path/to/database" assert args == {} user, password, host, port, path, args = _parseURI("sqlite:/:memory:") assert user is None assert password is None assert host is None assert port is None assert path == "/:memory:" assert args == {} if os.name == 'nt': user, password, host, port, path, args = \ _parseURI("sqlite:/C|/full/path/to/database") assert user is None assert password is None assert host is None assert port is None assert path == "/C:/full/path/to/database" assert args == {} user, password, host, port, path, args = \ _parseURI("sqlite:///C:/full/path/to/database") assert user is None assert password is None assert host is None assert port is None assert path == "/C:/full/path/to/database" assert args == {} def test_uri(): connection = DBConnection() connection.close = lambda: None connection.dbName, connection.host, connection.port, \ connection.user, connection.password, connection.db = \ 'mysql', 'host', None, None, None, 'database' assert connection.uri() == "mysql://host/database" connection.dbName, connection.host, connection.port, \ connection.user, connection.password, connection.db = \ 'mysql', 'host', None, 'user', 'pass word', 'database' assert connection.uri() == "mysql://user:pass%20word@host/database" connection.dbName, connection.host, connection.port, \ connection.user, connection.password, connection.db = \ 'postgres', 'host', None, 'user', None, 'database' assert connection.uri() == "postgres://user@host/database" connection.dbName, connection.host, connection.port, \ connection.user, connection.password, connection.db = \ 'postgres', 'host', 5432, None, None, 'database' assert connection.uri() == "postgres://host:5432/database" connection.dbName, connection.host, connection.port, \ connection.user, connection.password, connection.db = \ 'postgres', None, None, None, None, '/full/path/to/socket/database' assert connection.uri() == "postgres:///full/path/to/socket/database" connection.dbName, connection.host, connection.port, \ connection.user, connection.password, connection.db = \ 'postgres', 'host', None, 'us:er', 'p@ssword', 'database' assert connection.uri() == "postgres://us%3Aer:p%40ssword@host/database" connection = SQLiteConnection(None) connection.filename = '/full/path/to/database' assert connection.uri() == "sqlite:///full/path/to/database" connection.filename = ':memory:' assert connection.uri() == "sqlite:/:memory:" if os.name == 'nt': connection.filename = 'C:/full/path/to/database' assert connection.uri() == "sqlite:///C:/full/path/to/database" SQLObject-3.1.0/sqlobject/tests/test_default_style.py0000644000175000017500000000373112747416060022271 0ustar phdphd00000000000000""" Test the default styles, to guarantee consistency. """ from sqlobject import ForeignKey, MixedCaseStyle, MixedCaseUnderscoreStyle, \ SQLObject, StringCol, Style # Hash of styles versus the database names resulting from 'columns' below. columns = ["ABCUpper", "abc_lower", "ABCamelCaseColumn"] styles = { Style: columns, MixedCaseUnderscoreStyle: ["abc_upper", "abc_lower", "ab_camel_case_column"], MixedCaseStyle: ["ABCUpper", "Abc_lower", "ABCamelCaseColumn"], } # Hash of styles versus the database names # resulting from a foreign key named 'FKey'. fkey = ForeignKey("DefaultStyleTest", name="FKey") fkeys = { Style: "FKeyID", MixedCaseUnderscoreStyle: "f_key_id", MixedCaseStyle: "FKeyID", } def make_columns(): global columns columns = [] for col_name in columns: columns.append(StringCol(name=col_name, length=10)) def do_col_test(DefaultStyleTest, style, dbnames): DefaultStyleTest.sqlmeta.style = style() for col, old_dbname in zip(columns, dbnames): DefaultStyleTest.sqlmeta.addColumn(col) try: new_dbname = DefaultStyleTest.sqlmeta.columns[col.name].dbName assert new_dbname == old_dbname finally: if col.name in DefaultStyleTest.sqlmeta.columns: DefaultStyleTest.sqlmeta.delColumn(col) def do_fkey_test(DefaultStyleTest, style, dbname): DefaultStyleTest.sqlmeta.style = style() DefaultStyleTest.sqlmeta.addColumn(fkey) try: assert list(DefaultStyleTest.sqlmeta.columns.keys())[0] == "FKeyID" assert list(DefaultStyleTest.sqlmeta.columns.values())[0].dbName == \ dbname finally: DefaultStyleTest.sqlmeta.delColumn(fkey) class DefaultStyleTest(SQLObject): pass def test_default_styles(): make_columns() for style in styles: yield do_col_test, DefaultStyleTest, style, styles[style] yield do_fkey_test, DefaultStyleTest, style, fkeys[style] SQLObject-3.1.0/sqlobject/tests/test_inheritance.py0000644000175000017500000000120012747416060021703 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import setupClass ######################################## # Inheritance ######################################## class Super(SQLObject): name = StringCol(length=10) class Sub(Super): name2 = StringCol(length=10) def test_super(): setupClass(Super) setupClass(Sub) s1 = Super(name='one') Super(name='two') # s2 s3 = Super.get(s1.id) assert s1 == s3 def test_sub(): setupClass(Super) setupClass(Sub) s1 = Sub(name='one', name2='1') Sub(name='two', name2='2') # s2 s3 = Sub.get(s1.id) assert s1 == s3 SQLObject-3.1.0/sqlobject/tests/test_pickle.py0000644000175000017500000000233712747416060020675 0ustar phdphd00000000000000import pickle import py.test from sqlobject import IntCol, SQLObject, StringCol from sqlobject.tests.dbtest import getConnection, raises, setupClass ######################################## # Pickle instances ######################################## class TestPickle(SQLObject): question = StringCol() answer = IntCol() test_question = 'The Ulimate Question of Life, the Universe and Everything' test_answer = 42 def test_pickleCol(): setupClass(TestPickle) connection = TestPickle._connection test = TestPickle(question=test_question, answer=test_answer) pickle_data = pickle.dumps(test, pickle.HIGHEST_PROTOCOL) connection.cache.clear() test = pickle.loads(pickle_data) test2 = connection.cache.tryGet(test.id, TestPickle) assert test2 is test assert test.question == test_question assert test.answer == test_answer if (connection.dbName == 'sqlite') and connection._memory: py.test.skip("The following test requires a different connection") test = TestPickle.get( test.id, # make a different DB URI and open another connection connection=getConnection(registry='')) raises(pickle.PicklingError, pickle.dumps, test, pickle.HIGHEST_PROTOCOL) SQLObject-3.1.0/sqlobject/tests/test_perConnection.py0000644000175000017500000000116512747416060022232 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import getConnection ######################################## # Per-instance connection ######################################## class TestPerConnection(SQLObject): test = StringCol() def test_perConnection(): connection = getConnection() TestPerConnection.dropTable(connection=connection, ifExists=True) TestPerConnection.createTable(connection=connection) TestPerConnection(test='test', connection=connection) assert len(list(TestPerConnection.select( TestPerConnection.q.test == 'test', connection=connection))) == 1 SQLObject-3.1.0/sqlobject/tests/test_complex_sorting.py0000644000175000017500000000524512747416060022643 0ustar phdphd00000000000000from sqlobject import IntCol, SQLObject, StringCol, sqlmeta from sqlobject.tests.dbtest import inserts, setupClass # Test more complex orderBy clauses class ComplexNames(SQLObject): class sqlmeta(sqlmeta): table = 'names_table' defaultOrder = ['lastName', 'firstName', 'phone', 'age'] firstName = StringCol(length=30) lastName = StringCol(length=30) phone = StringCol(length=11) age = IntCol() def setupComplexNames(): setupClass(ComplexNames) inserts(ComplexNames, [('aj', 'baker', '555-444-333', 34), ('joe', 'robbins', '444-555-333', 34), ('tim', 'jackson', '555-444-222', 32), ('joe', 'baker', '222-111-000', 24), ('zoe', 'robbins', '444-555-333', 46)], schema='firstName lastName phone age') def nameList(names): result = [] for name in names: result.append('%s %s' % (name.firstName, name.lastName)) return result def firstList(names): return [n.firstName for n in names] def test_defaultComplexOrder(): setupComplexNames() assert nameList(ComplexNames.select()) == \ ['aj baker', 'joe baker', 'tim jackson', 'joe robbins', 'zoe robbins'] def test_complexOrders(): setupComplexNames() assert nameList(ComplexNames.select().orderBy(['age', 'phone', 'firstName', 'lastName'])) == \ ['joe baker', 'tim jackson', 'joe robbins', 'aj baker', 'zoe robbins'] assert nameList(ComplexNames.select().orderBy(['-age', 'phone', 'firstName', 'lastName'])) == \ ['zoe robbins', 'joe robbins', 'aj baker', 'tim jackson', 'joe baker'] assert nameList(ComplexNames.select().orderBy(['age', '-phone', 'firstName', 'lastName'])) == \ ['joe baker', 'tim jackson', 'aj baker', 'joe robbins', 'zoe robbins'] assert nameList(ComplexNames.select().orderBy(['-firstName', 'phone', 'lastName', 'age'])) == \ ['zoe robbins', 'tim jackson', 'joe baker', 'joe robbins', 'aj baker'] assert nameList(ComplexNames.select().orderBy(['-firstName', '-phone', 'lastName', 'age'])) == \ ['zoe robbins', 'tim jackson', 'joe robbins', 'joe baker', 'aj baker'] SQLObject-3.1.0/sqlobject/tests/test_auto.py0000644000175000017500000001470112747416060020374 0ustar phdphd00000000000000from datetime import datetime from py.test import raises from sqlobject import KeyCol, MultipleJoin, SQLObject, StringCol, \ classregistry, sqlmeta from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # Dynamic column tests ######################################## now = datetime.now class Person(SQLObject): class sqlmeta: defaultOrder = 'name' name = StringCol(length=100, dbName='name_col') class Phone(SQLObject): class sqlmeta: defaultOrder = 'phone' phone = StringCol(length=12) class TestPeople: def setup_method(self, meth): setupClass(Person) setupClass(Phone) for n in ['jane', 'tim', 'bob', 'jake']: Person(name=n) for p in ['555-555-5555', '555-394-2930', '444-382-4854']: Phone(phone=p) def test_defaultOrder(self): assert list(Person.select('all')) == list( Person.select('all', orderBy=Person.sqlmeta.defaultOrder)) def test_dynamicColumn(self): nickname = StringCol('nickname', length=10) Person.sqlmeta.addColumn(nickname, changeSchema=True) Person(name='robert', nickname='bob') assert ([p.name for p in Person.select('all')] == ['bob', 'jake', 'jane', 'robert', 'tim']) Person.sqlmeta.delColumn(nickname, changeSchema=True) def test_dynamicJoin(self): col = KeyCol('person', foreignKey='Person') Phone.sqlmeta.addColumn(col, changeSchema=True) join = MultipleJoin('Phone') Person.sqlmeta.addJoin(join) for phone in Phone.select('all'): if phone.phone.startswith('555'): phone.person = Person.selectBy(name='tim')[0] else: phone.person = Person.selectBy(name='bob')[0] l = [p.phone for p in Person.selectBy(name='tim')[0].phones] l.sort() assert l == ['555-394-2930', '555-555-5555'] Phone.sqlmeta.delColumn(col, changeSchema=True) Person.sqlmeta.delJoin(join) def _test_collidingName(self): class CollidingName(SQLObject): expire = StringCol() def test_collidingName(self): raises(AssertionError, Person.sqlmeta.addColumn, StringCol(name="name")) raises(AssertionError, Person.sqlmeta.addColumn, StringCol(name="_init")) raises(AssertionError, Person.sqlmeta.addColumn, StringCol(name="expire")) raises(AssertionError, Person.sqlmeta.addColumn, StringCol(name="set")) raises(AssertionError, self._test_collidingName) ######################################## # Auto class generation ######################################## class TestAuto: mysqlCreate = """ CREATE TABLE IF NOT EXISTS auto_test ( auto_id INT AUTO_INCREMENT PRIMARY KEY, first_name VARCHAR(100), last_name VARCHAR(200) NOT NULL, age INT DEFAULT NULL, created DATETIME NOT NULL, happy char(1) DEFAULT 'Y' NOT NULL, long_field TEXT, wannahavefun TINYINT DEFAULT 0 NOT NULL ) """ postgresCreate = """ CREATE TABLE auto_test ( auto_id SERIAL PRIMARY KEY, first_name VARCHAR(100), last_name VARCHAR(200) NOT NULL, age INT DEFAULT 0, created TIMESTAMP NOT NULL, happy char(1) DEFAULT 'Y' NOT NULL, long_field TEXT, wannahavefun BOOL DEFAULT FALSE NOT NULL ) """ rdbhostCreate = """ CREATE TABLE auto_test ( auto_id SERIAL PRIMARY KEY, first_name VARCHAR(100), last_name VARCHAR(200) NOT NULL, age INT DEFAULT 0, created VARCHAR(40) NOT NULL, happy char(1) DEFAULT 'Y' NOT NULL, long_field TEXT, wannahavefun BOOL DEFAULT FALSE NOT NULL ) """ sqliteCreate = """ CREATE TABLE auto_test ( auto_id INTEGER PRIMARY KEY AUTOINCREMENT , first_name VARCHAR(100), last_name VARCHAR(200) NOT NULL, age INT DEFAULT NULL, created DATETIME NOT NULL, happy char(1) DEFAULT 'Y' NOT NULL, long_field TEXT, wannahavefun INT DEFAULT 0 NOT NULL ) """ sybaseCreate = """ CREATE TABLE auto_test ( auto_id integer, first_name VARCHAR(100), last_name VARCHAR(200) NOT NULL, age INT DEFAULT 0, created DATETIME NOT NULL, happy char(1) DEFAULT 'Y' NOT NULL, long_field TEXT, wannahavefun BIT default(0) NOT NULL ) """ mssqlCreate = """ CREATE TABLE auto_test ( auto_id int identity(1,1), first_name VARCHAR(100), last_name VARCHAR(200) NOT NULL, age INT DEFAULT 0, created DATETIME NOT NULL, happy char(1) DEFAULT 'Y' NOT NULL, long_field TEXT, wannahavefun BIT default(0) NOT NULL ) """ mysqlDrop = """ DROP TABLE IF EXISTS auto_test """ postgresDrop = """ DROP TABLE auto_test """ sqliteDrop = sybaseDrop = mssqlDrop = rdbhostDrop = postgresDrop def setup_method(self, meth): conn = getConnection() dbName = conn.dbName creator = getattr(self, dbName + 'Create', None) if creator: conn.query(creator) def teardown_method(self, meth): conn = getConnection() dbName = conn.dbName dropper = getattr(self, dbName + 'Drop', None) if dropper: conn.query(dropper) def test_classCreate(self): class AutoTest(SQLObject): _connection = getConnection() class sqlmeta(sqlmeta): idName = 'auto_id' fromDatabase = True john = AutoTest(firstName='john', lastName='doe', age=10, created=now(), wannahavefun=False, longField='x' * 1000) jane = AutoTest(firstName='jane', lastName='doe', happy='N', created=now(), wannahavefun=True, longField='x' * 1000) assert not john.wannahavefun assert jane.wannahavefun assert john.longField == 'x' * 1000 assert jane.longField == 'x' * 1000 del classregistry.registry( AutoTest.sqlmeta.registry).classes['AutoTest'] columns = AutoTest.sqlmeta.columns assert columns["lastName"].dbName == "last_name" assert columns["wannahavefun"].dbName == "wannahavefun" SQLObject-3.1.0/sqlobject/tests/test_sqlobject_admin.py0000644000175000017500000000204612747416060022561 0ustar phdphd00000000000000# These tests are not enabled yet, but here are some working examples # of using createSQL so far. from sqlobject import SQLObject, StringCol class Test1(SQLObject): class sqlmeta: createSQL = "CREATE SEQUENCE db_test1_seq;" test1 = StringCol() class Test2(SQLObject): class sqlmeta: createSQL = ["CREATE SEQUENCE db_test2_seq;", "ALTER TABLE test2 ADD CHECK(test2 != '');"] test2 = StringCol() class Test3(SQLObject): class sqlmeta: createSQL = {'postgres': 'CREATE SEQUENCE db_test3_seq;', 'mysql': 'CREATE SEQUENCE db_test3_seq;'} test3 = StringCol() class Test4(SQLObject): class sqlmeta: createSQL = {'postgres': ['CREATE SEQUENCE db_test4_seq;', "ALTER TABLE test4 ADD CHECK(test4 != '');"], 'mysql': 'CREATE SEQUENCE db_test4_seq;'} test4 = StringCol() class Test5(SQLObject): class sqlmeta: createSQL = {'mysql': 'CREATE SEQUENCE db_test5_seq;'} test5 = StringCol() SQLObject-3.1.0/sqlobject/tests/test_sqlbuilder_importproxy.py0000644000175000017500000000256112747416060024267 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.sqlbuilder import Alias, ImportProxy, tablesUsedSet from sqlobject.views import ViewSQLObject def testSimple(): nyi = ImportProxy('NotYetImported') x = nyi.q.name class NotYetImported(SQLObject): name = StringCol(dbName='a_name') y = nyi.q.name assert str(x) == 'not_yet_imported.a_name' assert str(y) == 'not_yet_imported.a_name' def testAddition(): nyi = ImportProxy('NotYetImported2') x = nyi.q.name + nyi.q.name class NotYetImported2(SQLObject): name = StringCol(dbName='a_name') assert str(x) == \ '((not_yet_imported2.a_name) + (not_yet_imported2.a_name))' def testOnView(): nyi = ImportProxy('NotYetImportedV') x = nyi.q.name class NotYetImported3(SQLObject): name = StringCol(dbName='a_name') class NotYetImportedV(ViewSQLObject): class sqlmeta: idName = NotYetImported3.q.id name = StringCol(dbName=NotYetImported3.q.name) assert str(x) == 'not_yet_imported_v.name' def testAlias(): nyi = ImportProxy('NotYetImported4') y = Alias(nyi, 'y') x = y.q.name class NotYetImported4(SQLObject): name = StringCol(dbName='a_name') assert str(y) == 'not_yet_imported4 y' assert tablesUsedSet(x, None) == set(['not_yet_imported4 y']) assert str(x) == 'y.a_name' SQLObject-3.1.0/sqlobject/tests/test_csvexport.py0000644000175000017500000000535612747416060021467 0ustar phdphd00000000000000from __future__ import print_function try: from StringIO import StringIO except ImportError: from io import StringIO from sqlobject import IntCol, SQLObject, StringCol from sqlobject.util.csvexport import export_csv, export_csv_zip from .dbtest import setupClass def assert_export(result, *args, **kw): f = StringIO() kw['writer'] = f export_csv(*args, **kw) s = f.getvalue().replace('\r\n', '\n') if result.strip() != s.strip(): print('**Expected:') print(result) print('**Got:') print(s) assert result.strip() == s.strip() class SimpleCSV(SQLObject): name = StringCol() address = StringCol() address.csvTitle = 'Street Address' hidden = StringCol() hidden.noCSV = True class ComplexCSV(SQLObject): fname = StringCol() lname = StringCol() age = IntCol() extraCSVColumns = [('name', 'Full Name'), 'initials'] # initials should end up at the end then: csvColumnOrder = ['name', 'fname', 'lname', 'age'] def _get_name(self): return self.fname + ' ' + self.lname def _get_initials(self): return self.fname[0] + self.lname[0] def test_simple(): setupClass(SimpleCSV) SimpleCSV(name='Bob', address='432W', hidden='boo') SimpleCSV(name='Joe', address='123W', hidden='arg') assert_export("""\ name,Street Address Bob,432W Joe,123W """, SimpleCSV, orderBy='name') assert_export("""\ name,Street Address Joe,123W Bob,432W """, SimpleCSV, orderBy='address') assert_export("""\ name,Street Address Joe,123W """, SimpleCSV.selectBy(name='Joe')) def test_complex(): setupClass(ComplexCSV) ComplexCSV(fname='John', lname='Doe', age=40) ComplexCSV(fname='Bob', lname='Dylan', age=60) ComplexCSV(fname='Harriet', lname='Tubman', age=160) assert_export("""\ Full Name,fname,lname,age,initials John Doe,John,Doe,40,JD Bob Dylan,Bob,Dylan,60,BD Harriet Tubman,Harriet,Tubman,160,HT """, ComplexCSV, orderBy='lname') assert_export("""\ Full Name,fname,lname,age,initials Bob Dylan,Bob,Dylan,60,BD John Doe,John,Doe,40,JD """, ComplexCSV.select(ComplexCSV.q.lname.startswith('D'), orderBy='fname')) def test_zip(): # Just exercise tests, doesn't actually test results setupClass(SimpleCSV) SimpleCSV(name='Bob', address='432W', hidden='boo') SimpleCSV(name='Joe', address='123W', hidden='arg') setupClass(ComplexCSV) ComplexCSV(fname='John', lname='Doe', age=40) ComplexCSV(fname='Bob', lname='Dylan', age=60) ComplexCSV(fname='Harriet', lname='Tubman', age=160) s = export_csv_zip([SimpleCSV, ComplexCSV]) assert isinstance(s, bytes) and s s = export_csv_zip([SimpleCSV.selectBy(name='Bob'), (ComplexCSV, list(ComplexCSV.selectBy(fname='John')))]) SQLObject-3.1.0/sqlobject/tests/test_create_drop.py0000644000175000017500000000200012747416060021700 0ustar phdphd00000000000000from sqlobject import BLOBCol, DateTimeCol, IntCol, SQLObject, StringCol, \ sqlmeta from sqlobject.tests.dbtest import getConnection class TestCreateDrop(SQLObject): class sqlmeta(sqlmeta): idName = 'test_id_here' table = 'test_create_drop_table' name = StringCol() number = IntCol() time = DateTimeCol() short = StringCol(length=10) blobcol = BLOBCol() def test_create_drop(): conn = getConnection() TestCreateDrop.setConnection(conn) TestCreateDrop.dropTable(ifExists=True) assert not conn.tableExists(TestCreateDrop.sqlmeta.table) TestCreateDrop.createTable(ifNotExists=True) assert conn.tableExists(TestCreateDrop.sqlmeta.table) TestCreateDrop.createTable(ifNotExists=True) assert conn.tableExists(TestCreateDrop.sqlmeta.table) TestCreateDrop.dropTable(ifExists=True) assert not conn.tableExists(TestCreateDrop.sqlmeta.table) TestCreateDrop.dropTable(ifExists=True) assert not conn.tableExists(TestCreateDrop.sqlmeta.table) SQLObject-3.1.0/sqlobject/tests/test_SQLRelatedJoin.py0000644000175000017500000000354712747416060022212 0ustar phdphd00000000000000import py.test from sqlobject import RelatedJoin, SQLObject, SQLRelatedJoin, StringCol from sqlobject.tests.dbtest import setupClass, supports class Fighter(SQLObject): class sqlmeta: idName = 'fighter_id' # test on a non-standard way name = StringCol() tourtments = RelatedJoin('Tourtment') class Tourtment(SQLObject): class sqlmeta: table = 'competition' # test on a non-standard way name = StringCol() fightersAsList = RelatedJoin('Fighter') fightersAsSResult = SQLRelatedJoin('Fighter') def createAllTables(): setupClass(Fighter) setupClass(Tourtment) def test_1(): createAllTables() # create some tourtments t1 = Tourtment(name='Tourtment #1') t2 = Tourtment(name='Tourtment #2') t3 = Tourtment(name='Tourtment #3') # create some fighters gokou = Fighter(name='gokou') vegeta = Fighter(name='vegeta') gohan = Fighter(name='gohan') trunks = Fighter(name='trunks') # relating them t1.addFighter(gokou) t1.addFighter(vegeta) t1.addFighter(gohan) t2.addFighter(gokou) t2.addFighter(vegeta) t2.addFighter(trunks) t3.addFighter(gohan) t3.addFighter(trunks) # do some selects for i, j in zip(t1.fightersAsList, t1.fightersAsSResult): assert i is j assert len(t2.fightersAsList) == t2.fightersAsSResult.count() def test_related_join_transaction(): if not supports('transactions'): py.test.skip("Transactions aren't supported") createAllTables() trans = Tourtment._connection.transaction() try: t1 = Tourtment(name='Tourtment #1', connection=trans) t1.addFighter(Fighter(name='Jim', connection=trans)) assert t1.fightersAsSResult.count() == 1 assert t1.fightersAsSResult[0]._connection == trans finally: trans.commit(True) Tourtment._connection.autoCommit = True SQLObject-3.1.0/sqlobject/tests/test_unicode.py0000644000175000017500000001037112747416060021051 0ustar phdphd00000000000000import py.test from sqlobject import AND, IntCol, OR, SQLObject, UnicodeCol from sqlobject.compat import PY2 from sqlobject.tests.dbtest import raises, setupClass ######################################## # Unicode columns ######################################## class TestUnicode(SQLObject): count = IntCol(alternateID=True) col1 = UnicodeCol(alternateID=True, length=100) if PY2: col2 = UnicodeCol(dbEncoding='latin1') data = [u'\u00f0', u'test', 'ascii test'] items = [] def setup(): global items items = [] setupClass(TestUnicode) if TestUnicode._connection.dbName == 'postgres': if PY2: dbEncoding = 'latin1' else: dbEncoding = 'utf8' TestUnicode._connection.query('SET client_encoding TO %s' % dbEncoding) if PY2: for i, s in enumerate(data): items.append(TestUnicode(count=i, col1=s, col2=s)) else: for i, s in enumerate(data): items.append(TestUnicode(count=i, col1=s)) def test_create(): setup() for s, item in zip(data, items): assert item.col1 == s if PY2: assert item.col2 == s conn = TestUnicode._connection if PY2: rows = conn.queryAll(""" SELECT count, col1, col2 FROM test_unicode ORDER BY count """) for count, col1, col2 in rows: assert data[count].encode('utf-8') == col1 assert data[count].encode('latin1') == col2 else: rows = conn.queryAll(""" SELECT count, col1 FROM test_unicode ORDER BY count """) # On python 3, everthings already decoded to unicode for count, col1 in rows: assert data[count] == col1 def _test_select(): for i, value in enumerate(data): rows = list(TestUnicode.select(TestUnicode.q.col1 == value)) assert len(rows) == 1 if PY2: rows = list(TestUnicode.select(TestUnicode.q.col2 == value)) assert len(rows) == 1 rows = list(TestUnicode.select(AND( TestUnicode.q.col1 == value, TestUnicode.q.col2 == value ))) assert len(rows) == 1 rows = list(TestUnicode.selectBy(col1=value)) assert len(rows) == 1 if PY2: rows = list(TestUnicode.selectBy(col2=value)) assert len(rows) == 1 rows = list(TestUnicode.selectBy(col1=value, col2=value)) assert len(rows) == 1 row = TestUnicode.byCol1(value) assert row.count == i if PY2: rows = list(TestUnicode.select(OR( TestUnicode.q.col1 == u'\u00f0', TestUnicode.q.col2 == u'test' ))) assert len(rows) == 2 rows = list(TestUnicode.selectBy(col1=u'\u00f0', col2=u'test')) assert len(rows) == 0 # starts/endswith/contains rows = list(TestUnicode.select(TestUnicode.q.col1.startswith("test"))) assert len(rows) == 1 rows = list(TestUnicode.select(TestUnicode.q.col1.endswith("test"))) assert len(rows) == 2 rows = list(TestUnicode.select(TestUnicode.q.col1.contains("test"))) assert len(rows) == 2 rows = list(TestUnicode.select(TestUnicode.q.col1.startswith(u"\u00f0"))) assert len(rows) == 1 rows = list(TestUnicode.select(TestUnicode.q.col1.endswith(u"\u00f0"))) assert len(rows) == 1 rows = list(TestUnicode.select(TestUnicode.q.col1.contains(u"\u00f0"))) assert len(rows) == 1 def test_select(): setup() _test_select() def test_dbEncoding(): if not PY2: # Python 3 mostly ignores dbEncoding py.test.skip("This test is for python 2") setup() TestUnicode.sqlmeta.dbEncoding = 'utf-8' _test_select() TestUnicode.sqlmeta.dbEncoding = 'latin-1' raises(AssertionError, _test_select) TestUnicode.sqlmeta.dbEncoding = 'ascii' raises(UnicodeEncodeError, _test_select) TestUnicode.sqlmeta.dbEncoding = None TestUnicode._connection.dbEncoding = 'utf-8' _test_select() TestUnicode._connection.dbEncoding = 'latin-1' raises(AssertionError, _test_select) TestUnicode._connection.dbEncoding = 'ascii' raises(UnicodeEncodeError, _test_select) del TestUnicode.sqlmeta.dbEncoding TestUnicode._connection.dbEncoding = 'utf-8' SQLObject-3.1.0/sqlobject/tests/test_converters.py0000644000175000017500000001645312467733425021632 0ustar phdphd00000000000000from datetime import timedelta from sqlobject.converters import registerConverter, sqlrepr, \ quote_str, unquote_str from sqlobject.sqlbuilder import SQLExpression, SQLObjectField, \ Select, Insert, Update, Delete, Replace, \ SQLTrueClauseClass, SQLConstant, SQLPrefix, SQLCall, SQLOp, \ _LikeQuoted class TestClass: def __repr__(self): return '' def TestClassConverter(value, db): return repr(value) registerConverter(TestClass, TestClassConverter) class NewTestClass: __metaclass__ = type def __repr__(self): return '' def NewTestClassConverter(value, db): return repr(value) registerConverter(NewTestClass, NewTestClassConverter) def _sqlrepr(self, db): return '<%s>' % self.__class__.__name__ SQLExpression.__sqlrepr__ = _sqlrepr ############################################################ # Tests ############################################################ def test_simple_string(): assert sqlrepr('A String', 'firebird') == "'A String'" def test_string_newline(): assert sqlrepr('A String\nAnother', 'postgres') == "E'A String\\nAnother'" assert sqlrepr('A String\nAnother', 'sqlite') == "'A String\nAnother'" def test_string_tab(): assert sqlrepr('A String\tAnother', 'postgres') == "E'A String\\tAnother'" def test_string_r(): assert sqlrepr('A String\rAnother', 'postgres') == "E'A String\\rAnother'" def test_string_b(): assert sqlrepr('A String\bAnother', 'postgres') == "E'A String\\bAnother'" def test_string_000(): assert sqlrepr('A String\000Another', 'postgres') == \ "E'A String\\0Another'" def test_string_(): assert sqlrepr('A String\tAnother', 'postgres') == "E'A String\\tAnother'" assert sqlrepr('A String\'Another', 'firebird') == "'A String''Another'" def test_simple_unicode(): assert sqlrepr(u'A String', 'postgres') == "'A String'" def test_integer(): assert sqlrepr(10) == "10" def test_float(): assert sqlrepr(10.01) == "10.01" def test_none(): assert sqlrepr(None) == "NULL" def test_list(): assert sqlrepr(['one', 'two', 'three'], 'postgres') == \ "('one', 'two', 'three')" def test_tuple(): assert sqlrepr(('one', 'two', 'three'), 'postgres') == \ "('one', 'two', 'three')" def test_bool(): assert sqlrepr(True, 'postgres') == "'t'" assert sqlrepr(False, 'postgres') == "'f'" assert sqlrepr(True, 'mysql') == "1" assert sqlrepr(False, 'mysql') == "0" def test_datetime(): from datetime import datetime, date, time assert sqlrepr(datetime(2005, 7, 14, 13, 31, 2)) == \ "'2005-07-14 13:31:02.000000'" assert sqlrepr(date(2005, 7, 14)) == "'2005-07-14'" assert sqlrepr(time(13, 31, 2)) == "'13:31:02.000000'" # now dates before 1900 assert sqlrepr(datetime(1428, 7, 14, 13, 31, 2)) == \ "'1428-07-14 13:31:02.000000'" assert sqlrepr(date(1428, 7, 14)) == "'1428-07-14'" def test_instance(): instance = TestClass() assert sqlrepr(instance) == repr(instance) def test_newstyle(): instance = NewTestClass() assert sqlrepr(instance) == repr(instance) def test_sqlexpr(): instance = SQLExpression() assert sqlrepr(instance) == repr(instance) def test_sqlobjectfield(): instance = SQLObjectField('test', 'test', 'test', None, None) assert sqlrepr(instance) == repr(instance) def test_select(): instance = Select('test') assert sqlrepr(instance, 'mysql') == "SELECT test" def test_insert(): # Single column, no keyword arguments. instance = Insert('test', [('test',)]) assert sqlrepr(instance, 'mysql') == "INSERT INTO test VALUES ('test')" # Multiple columns, no keyword arguments. instance2 = Insert('test', [('1st', '2nd', '3th', '4th')]) assert sqlrepr(instance2, 'postgres') == \ "INSERT INTO test VALUES ('1st', '2nd', '3th', '4th')" # Multiple rows, multiple columns, "valueList" keyword argument. instance3 = Insert('test', valueList=[('a1', 'b1'), ('a2', 'b2'), ('a3', 'b3')]) assert sqlrepr(instance3, 'sqlite') == \ "INSERT INTO test VALUES ('a1', 'b1'), ('a2', 'b2'), ('a3', 'b3')" # Multiple columns, "values" keyword argument. instance4 = Insert('test', values=('v1', 'v2', 'v3')) assert sqlrepr(instance4, 'mysql') == \ "INSERT INTO test VALUES ('v1', 'v2', 'v3')" # Single column, "valueList" keyword argument. instance5 = Insert('test', valueList=[('v1',)]) assert sqlrepr(instance5, 'mysql') == "INSERT INTO test VALUES ('v1')" # Multiple rows, Multiple columns, template. instance6 = Insert('test', valueList=[('a1', 'b1'), ('a2', 'b2')], template=['col1', 'col2']) assert sqlrepr(instance6, 'mysql') == \ "INSERT INTO test (col1, col2) VALUES ('a1', 'b1'), ('a2', 'b2')" # Multiple columns, implicit template (dictionary value). instance7 = Insert('test', valueList=[{'col1': 'a1', 'col2': 'b1'}]) assert sqlrepr(instance7, 'mysql') == \ "INSERT INTO test (col1, col2) VALUES ('a1', 'b1')" # Multiple rows, Multiple columns, implicit template. instance8 = Insert('test', valueList=[{'col1': 'a1', 'col2': 'b1'}, {'col1': 'a2', 'col2': 'b2'}]) assert sqlrepr(instance8, 'mysql') == \ "INSERT INTO test (col1, col2) VALUES ('a1', 'b1'), ('a2', 'b2')" def test_update(): instance = Update('test', {'test': 'test'}) assert sqlrepr(instance, 'mysql') == "UPDATE test SET test='test'" def test_delete(): instance = Delete('test', None) assert sqlrepr(instance, 'mysql') == "DELETE FROM test" def test_replace(): instance = Replace('test', {'test': 'test'}) assert sqlrepr(instance, 'mysql') == "REPLACE test SET test='test'" def test_trueclause(): instance = SQLTrueClauseClass() assert sqlrepr(instance) == repr(instance) def test_op(): instance = SQLOp('and', 'this', 'that') assert sqlrepr(instance, 'mysql') == "(('this') AND ('that'))" def test_call(): instance = SQLCall('test', ('test',)) assert sqlrepr(instance, 'mysql') == "'test'('test')" def test_constant(): instance = SQLConstant('test') assert sqlrepr(instance) == repr(instance) def test_prefix(): instance = SQLPrefix('test', 'test') assert sqlrepr(instance, 'mysql') == "test 'test'" def test_dict(): assert sqlrepr({"key": "value"}, "sqlite") == "('key')" def test_sets(): try: set except NameError: pass else: assert sqlrepr(set([1])) == "(1)" def test_timedelta(): assert sqlrepr(timedelta(seconds=30 * 60)) == \ "INTERVAL '0 days 1800 seconds'" def test_quote_unquote_str(): assert quote_str('test%', 'postgres') == "'test%'" assert quote_str('test%', 'sqlite') == "'test%'" assert quote_str('test\%', 'postgres') == "E'test\\%'" assert quote_str('test\\%', 'sqlite') == "'test\%'" assert unquote_str("'test%'") == 'test%' assert unquote_str("'test\\%'") == 'test\\%' assert unquote_str("E'test\\%'") == 'test\\%' def test_like_quoted(): assert sqlrepr(_LikeQuoted('test'), 'postgres') == "'test'" assert sqlrepr(_LikeQuoted('test'), 'sqlite') == "'test'" assert sqlrepr(_LikeQuoted('test%'), 'postgres') == r"E'test\\%'" assert sqlrepr(_LikeQuoted('test%'), 'sqlite') == r"'test\%'" SQLObject-3.1.0/sqlobject/tests/test_new_joins.py0000644000175000017500000001203212747416060021412 0ustar phdphd00000000000000from __future__ import print_function from sqlobject import ForeignKey, ManyToMany, OneToMany, SQLObject, StringCol from sqlobject.tests.dbtest import setupClass ######################################## # Joins ######################################## class PersonJoinerNew(SQLObject): name = StringCol(length=40, alternateID=True) addressJoiners = ManyToMany('AddressJoinerNew') class AddressJoinerNew(SQLObject): zip = StringCol(length=5, alternateID=True) personJoiners = ManyToMany('PersonJoinerNew') class ImplicitJoiningSONew(SQLObject): foo = ManyToMany('Bar') class ExplicitJoiningSONew(SQLObject): foo = OneToMany('Bar') class TestJoin: def setup_method(self, meth): setupClass(PersonJoinerNew) setupClass(AddressJoinerNew) for n in ['bob', 'tim', 'jane', 'joe', 'fred', 'barb']: PersonJoinerNew(name=n) for z in ['11111', '22222', '33333', '44444']: AddressJoinerNew(zip=z) def test_join(self): b = PersonJoinerNew.byName('bob') assert list(b.addressJoiners) == [] z = AddressJoinerNew.byZip('11111') b.addressJoiners.add(z) self.assertZipsEqual(b.addressJoiners, ['11111']) print(str(z.personJoiners), repr(z.personJoiners)) self.assertNamesEqual(z.personJoiners, ['bob']) z2 = AddressJoinerNew.byZip('22222') b.addressJoiners.add(z2) print(str(b.addressJoiners)) self.assertZipsEqual(b.addressJoiners, ['11111', '22222']) self.assertNamesEqual(z2.personJoiners, ['bob']) b.addressJoiners.remove(z) self.assertZipsEqual(b.addressJoiners, ['22222']) self.assertNamesEqual(z.personJoiners, []) def assertZipsEqual(self, zips, dest): assert [a.zip for a in zips] == dest def assertNamesEqual(self, people, dest): assert [p.name for p in people] == dest def test_joinAttributeWithUnderscores(self): # Make sure that the implicit setting of joinMethodName works assert hasattr(ImplicitJoiningSONew, 'foo') assert not hasattr(ImplicitJoiningSONew, 'bars') # And make sure explicit setting also works assert hasattr(ExplicitJoiningSONew, 'foo') assert not hasattr(ExplicitJoiningSONew, 'bars') class PersonJoinerNew2(SQLObject): name = StringCol('name', length=40, alternateID=True) addressJoiner2s = OneToMany('AddressJoinerNew2') class AddressJoinerNew2(SQLObject): class sqlmeta: defaultOrder = ['-zip', 'plus4'] zip = StringCol(length=5) plus4 = StringCol(length=4, default=None) personJoinerNew2 = ForeignKey('PersonJoinerNew2') class TestJoin2: def setup_method(self, meth): setupClass([PersonJoinerNew2, AddressJoinerNew2]) p1 = PersonJoinerNew2(name='bob') p2 = PersonJoinerNew2(name='sally') for z in ['11111', '22222', '33333']: AddressJoinerNew2(zip=z, personJoinerNew2=p1) AddressJoinerNew2(zip='00000', personJoinerNew2=p2) def test_basic(self): bob = PersonJoinerNew2.byName('bob') sally = PersonJoinerNew2.byName('sally') print(bob.addressJoiner2s) print(bob) assert len(list(bob.addressJoiner2s)) == 3 assert len(list(sally.addressJoiner2s)) == 1 bob.addressJoiner2s[0].destroySelf() assert len(list(bob.addressJoiner2s)) == 2 z = bob.addressJoiner2s[0] z.zip = 'xxxxx' id = z.id del z z = AddressJoinerNew2.get(id) assert z.zip == 'xxxxx' def test_defaultOrder(self): p1 = PersonJoinerNew2.byName('bob') assert ([i.zip for i in p1.addressJoiner2s] == ['33333', '22222', '11111']) _personJoiner3_getters = [] _personJoiner3_setters = [] class PersonJoinerNew3(SQLObject): name = StringCol('name', length=40, alternateID=True) addressJoinerNew3s = OneToMany('AddressJoinerNew3') class AddressJoinerNew3(SQLObject): zip = StringCol(length=5) personJoinerNew3 = ForeignKey('PersonJoinerNew3') def _get_personJoinerNew3(self): value = self._SO_get_personJoinerNew3() _personJoiner3_getters.append((self, value)) return value def _set_personJoinerNew3(self, value): self._SO_set_personJoinerNew3(value) _personJoiner3_setters.append((self, value)) class TestJoin3: def setup_method(self, meth): setupClass([PersonJoinerNew3, AddressJoinerNew3]) p1 = PersonJoinerNew3(name='bob') p2 = PersonJoinerNew3(name='sally') for z in ['11111', '22222', '33333']: AddressJoinerNew3(zip=z, personJoinerNew3=p1) AddressJoinerNew3(zip='00000', personJoinerNew3=p2) def test_accessors(self): assert len(list(_personJoiner3_getters)) == 0 assert len(list(_personJoiner3_setters)) == 4 bob = PersonJoinerNew3.byName('bob') for addressJoiner3 in bob.addressJoinerNew3s: addressJoiner3.personJoinerNew3 assert len(list(_personJoiner3_getters)) == 3 assert len(list(_personJoiner3_setters)) == 4 SQLObject-3.1.0/sqlobject/tests/test_setters.py0000644000175000017500000000130512747416060021111 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import setupClass class TestPlainAndNonPlainSetter(SQLObject): firstName = StringCol(length=50, dbName='fname_col', default=None) lastName = StringCol(length=50, dbName='lname_col', default=None) def _set_name(self, v): firstName, lastName = v.split() self.firstName = firstName self.lastName = lastName def _get_name(self): return "%s %s" % (self.firstName, self.lastName) def test_create(): setupClass(TestPlainAndNonPlainSetter) t = TestPlainAndNonPlainSetter(name='John Doe') assert t.firstName == 'John' assert t.lastName == 'Doe' assert t.name == 'John Doe' SQLObject-3.1.0/sqlobject/tests/test_lazy.py0000644000175000017500000001265012747416060020404 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import setupClass ######################################## # Lazy updates ######################################## class Lazy(SQLObject): class sqlmeta: lazyUpdate = True name = StringCol() other = StringCol(default='nothing') third = StringCol(default='third') class TestLazyTest: def setup_method(self, meth): # All this stuff is so that we can track when the connection # does an actual update; we put in a new _SO_update method # that calls the original and sets an instance variable that # we can later check. setupClass(Lazy) self.conn = Lazy._connection self.conn.didUpdate = False self._oldUpdate = self.conn._SO_update newUpdate = ( lambda so, values, s=self, c=self.conn, o=self._oldUpdate: self._alternateUpdate(so, values, c, o)) self.conn._SO_update = newUpdate def teardown_method(self, meth): self.conn._SO_update = self._oldUpdate del self._oldUpdate def _alternateUpdate(self, so, values, conn, oldUpdate): conn.didUpdate = True return oldUpdate(so, values) def test_lazy(self): assert not self.conn.didUpdate obj = Lazy(name='tim') # We just did an insert, but not an update: assert not self.conn.didUpdate obj.set(name='joe') assert obj.sqlmeta.dirty assert obj.name == 'joe' assert not self.conn.didUpdate obj.syncUpdate() assert obj.name == 'joe' assert self.conn.didUpdate assert not obj.sqlmeta.dirty assert obj.name == 'joe' self.conn.didUpdate = False obj = Lazy(name='frank') obj.name = 'joe' assert not self.conn.didUpdate assert obj.sqlmeta.dirty assert obj.name == 'joe' obj.name = 'joe2' assert not self.conn.didUpdate assert obj.sqlmeta.dirty assert obj.name == 'joe2' obj.syncUpdate() assert obj.name == 'joe2' assert not obj.sqlmeta.dirty assert self.conn.didUpdate self.conn.didUpdate = False obj = Lazy(name='loaded') assert not obj.sqlmeta.dirty assert not self.conn.didUpdate assert obj.name == 'loaded' obj.name = 'unloaded' assert obj.sqlmeta.dirty assert obj.name == 'unloaded' assert not self.conn.didUpdate obj.sync() assert not obj.sqlmeta.dirty assert obj.name == 'unloaded' assert self.conn.didUpdate self.conn.didUpdate = False obj.name = 'whatever' assert obj.sqlmeta.dirty assert obj.name == 'whatever' assert not self.conn.didUpdate obj._SO_loadValue('name') assert obj.sqlmeta.dirty assert obj.name == 'whatever' assert not self.conn.didUpdate obj._SO_loadValue('other') assert obj.name == 'whatever' assert not self.conn.didUpdate obj.syncUpdate() assert self.conn.didUpdate self.conn.didUpdate = False # Now, check that get() doesn't screw # cached objects' validator state. obj_id = obj.id old_state = obj._SO_validatorState obj = Lazy.get(obj_id) assert not obj.sqlmeta.dirty assert not self.conn.didUpdate assert obj._SO_validatorState is old_state assert obj.name == 'whatever' obj.name = 'unloaded' assert obj.name == 'unloaded' assert obj.sqlmeta.dirty assert not self.conn.didUpdate # Fetch the object again with get() and # make sure sqlmeta.dirty is still set, as the # object should come from the cache. obj = Lazy.get(obj_id) assert obj.sqlmeta.dirty assert not self.conn.didUpdate assert obj.name == 'unloaded' obj.syncUpdate() assert self.conn.didUpdate assert not obj.sqlmeta.dirty self.conn.didUpdate = False # Then clear the cache, and try a get() # again, to make sure stuf like _SO_createdValues # is properly initialized. self.conn.cache.clear() obj = Lazy.get(obj_id) assert not obj.sqlmeta.dirty assert not self.conn.didUpdate assert obj.name == 'unloaded' obj.name = 'spongebob' assert obj.name == 'spongebob' assert obj.sqlmeta.dirty assert not self.conn.didUpdate obj.syncUpdate() assert self.conn.didUpdate assert not obj.sqlmeta.dirty self.conn.didUpdate = False obj = Lazy(name='last') assert not obj.sqlmeta.dirty obj.syncUpdate() assert not self.conn.didUpdate assert not obj.sqlmeta.dirty # Check that setting multiple values # actually works. This was broken # and just worked because we were testing # only one value at a time, so 'name' # had the right value after the for loop *wink* # Also, check that passing a name that is not # a valid column doesn't break, but instead # just does a plain setattr. obj.set(name='first', other='who', third='yes') assert obj.name == 'first' assert obj.other == 'who' assert obj.third == 'yes' assert obj.sqlmeta.dirty assert not self.conn.didUpdate obj.syncUpdate() assert self.conn.didUpdate assert not obj.sqlmeta.dirty SQLObject-3.1.0/sqlobject/tests/test_select_through.py0000644000175000017500000000337712747416060022452 0ustar phdphd00000000000000from sqlobject import ForeignKey, SQLMultipleJoin, SQLObject, SQLRelatedJoin, \ StringCol from sqlobject.tests.dbtest import inserts, setupClass import py # Tests retrieving objects through a join/fk on a selectResults class SRThrough1(SQLObject): three = ForeignKey('SRThrough3') twos = SQLMultipleJoin('SRThrough2', joinColumn='oneID') class SRThrough2(SQLObject): one = ForeignKey('SRThrough1') threes = SQLRelatedJoin('SRThrough3', addRemoveName='Three') class SRThrough3(SQLObject): name = StringCol() ones = SQLMultipleJoin('SRThrough1', joinColumn='threeID') twos = SQLRelatedJoin('SRThrough2') def setup_module(mod): global ones, twos, threes setupClass([SRThrough3, SRThrough1, SRThrough2]) threes = inserts(SRThrough3, [('a',), ('b',), ('c',)], 'name') ones = inserts(SRThrough1, [(threes[0].id,), (threes[0].id,), (threes[2].id,)], 'threeID') twos = inserts(SRThrough2, [(ones[0].id,), (ones[1].id,), (ones[2].id,)], 'oneID') twos[0].addThree(threes[0]) twos[0].addThree(threes[1]) def testBadRef(): py.test.raises(AttributeError, 'threes[0].throughTo.four') def testThroughFK(): assert list(threes[0].ones.throughTo.three) == [threes[0]] def testThroughMultipleJoin(): assert list(threes[0].ones.throughTo.twos) == [twos[0], twos[1]] def testThroughRelatedJoin(): assert list(threes[0].twos.throughTo.threes) == [threes[0], threes[1]] assert list( SRThrough3.select(SRThrough3.q.id == threes[0].id).throughTo.twos) == \ list(threes[0].twos) def testThroughFKAndJoin(): assert list(threes[0].ones.throughTo.three.throughTo.twos) == [twos[0]] SQLObject-3.1.0/sqlobject/tests/test_NoneValuedResultItem.py0000644000175000017500000000157612747416060023510 0ustar phdphd00000000000000# Test that selectResults handle NULL values from, for example, outer joins. from sqlobject import ForeignKey, SQLObject, StringCol, sqlbuilder from sqlobject.tests.dbtest import setupClass class TestComposer(SQLObject): name = StringCol() class TestWork(SQLObject): class sqlmeta: idName = "work_id" composer = ForeignKey('TestComposer') title = StringCol() def test1(): setupClass([TestComposer, TestWork]) c = TestComposer(name='Mahler, Gustav') w = TestWork(composer=c, title='Symphony No. 9') TestComposer(name='Bruckner, Anton') # but don't add any works for Bruckner # do a left join, a common use case that often involves NULL results s = TestWork.select(join=sqlbuilder.LEFTJOINOn(TestComposer, TestWork, TestComposer.q.id == TestWork.q.composerID)) assert tuple(s) == (w, None) SQLObject-3.1.0/sqlobject/tests/test_sorting.py0000644000175000017500000000506412747416060021113 0ustar phdphd00000000000000from sqlobject import DESC, SQLObject, StringCol, sqlmeta from sqlobject.tests.dbtest import inserts, setupClass class Names(SQLObject): class sqlmeta(sqlmeta): table = 'names_table' defaultOrder = ['lastName', 'firstName'] firstName = StringCol(length=30) lastName = StringCol(length=30) def setupNames(): setupClass(Names) inserts(Names, [('aj', 'baker'), ('joe', 'robbins'), ('tim', 'jackson'), ('joe', 'baker'), ('zoe', 'robbins')], schema='firstName lastName') def nameList(names): result = [] for name in names: result.append('%s %s' % (name.firstName, name.lastName)) return result def firstList(names): return [n.firstName for n in names] def test_defaultOrder(): setupNames() assert nameList(Names.select()) == \ ['aj baker', 'joe baker', 'tim jackson', 'joe robbins', 'zoe robbins'] def test_otherOrder(): setupNames() assert nameList(Names.select().orderBy(['firstName', 'lastName'])) == \ ['aj baker', 'joe baker', 'joe robbins', 'tim jackson', 'zoe robbins'] def test_untranslatedColumnOrder(): setupNames() assert nameList(Names.select().orderBy(['first_name', 'last_name'])) == \ ['aj baker', 'joe baker', 'joe robbins', 'tim jackson', 'zoe robbins'] def test_singleUntranslatedColumnOrder(): setupNames() assert firstList(Names.select().orderBy('firstName')) == \ ['aj', 'joe', 'joe', 'tim', 'zoe'] assert firstList(Names.select().orderBy('first_name')) == \ ['aj', 'joe', 'joe', 'tim', 'zoe'] assert firstList(Names.select().orderBy('-firstName')) == \ ['zoe', 'tim', 'joe', 'joe', 'aj'] assert firstList(Names.select().orderBy(u'-first_name')) == \ ['zoe', 'tim', 'joe', 'joe', 'aj'] assert firstList(Names.select().orderBy(Names.q.firstName)) == \ ['aj', 'joe', 'joe', 'tim', 'zoe'] assert firstList(Names.select().orderBy('firstName').reversed()) == \ ['zoe', 'tim', 'joe', 'joe', 'aj'] assert firstList(Names.select().orderBy('-firstName').reversed()) == \ ['aj', 'joe', 'joe', 'tim', 'zoe'] assert firstList(Names.select().orderBy(DESC(Names.q.firstName))) == \ ['zoe', 'tim', 'joe', 'joe', 'aj'] assert firstList(Names.select().orderBy(Names.q.firstName).reversed()) == \ ['zoe', 'tim', 'joe', 'joe', 'aj'] assert firstList( Names.select().orderBy(DESC(Names.q.firstName)).reversed()) == \ ['aj', 'joe', 'joe', 'tim', 'zoe'] SQLObject-3.1.0/sqlobject/tests/test_declarative.py0000644000175000017500000000363612747416060021714 0ustar phdphd00000000000000from sqlobject.declarative import Declarative class A1(Declarative): a = 1 b = [] class A2(A1): a = 5 A3 = A2(b=5) def test_a_classes(): assert A1.a == 1 assert A1.singleton().a == 1 assert A1.b is A2.b assert A3.b == 5 assert A1.declarative_count == A1.singleton().declarative_count assert A1.declarative_count < A2.declarative_count assert A2.singleton() is not A1.singleton() assert A3.singleton().b == A3.b class B1(Declarative): attrs = [] def __classinit__(cls, new_attrs): Declarative.__classinit__(cls, new_attrs) cls.attrs = cls.add_attrs(cls.attrs, new_attrs) def __instanceinit__(self, new_attrs): Declarative.__instanceinit__(self, new_attrs) self.attrs = self.add_attrs(self.attrs, new_attrs) @staticmethod def add_attrs(old_attrs, new_attrs): old_attrs = old_attrs[:] for name in new_attrs.keys(): if (name in old_attrs or name.startswith('_') or name in ('add_attrs', 'declarative_count', 'attrs')): continue old_attrs.append(name) old_attrs.sort() return old_attrs c = 1 class B2(B1): g = 3 def __classinit__(cls, new_attrs): new_attrs['test'] = 'whatever' B1.__classinit__(cls, new_attrs) B3 = B2(c=5, d=3) B4 = B3(d=5) B5 = B1(a=1) def test_b_classes(): assert B1.attrs == ['c'] assert B1.c == 1 assert B2.attrs == ['c', 'g', 'test'] assert B3.d == 3 assert B4.d == 5 assert B5.a == 1 assert B5.attrs == ['a', 'c'] assert B3.attrs == ['c', 'd', 'g', 'test'] assert B4.attrs == ['c', 'd', 'g', 'test'] order = [B1, B1.singleton(), B2, B2.singleton(), B3, B3.singleton(), B4, B4.singleton(), B5, B5.singleton()] last = 0 for obj in order: assert obj.declarative_count >= last last = obj.declarative_count SQLObject-3.1.0/sqlobject/tests/test_indexes.py0000644000175000017500000000602212747416060021060 0ustar phdphd00000000000000import py.test from sqlobject import DatabaseIndex, ForeignKey, IntCol, MultipleJoin, \ SQLObject, StringCol from sqlobject.dberrors import DatabaseError, IntegrityError, \ OperationalError, ProgrammingError from sqlobject.tests.dbtest import raises, setupClass, supports ######################################## # Indexes ######################################## class SOIndex1(SQLObject): name = StringCol(length=100) number = IntCol() nameIndex = DatabaseIndex('name', unique=True) nameIndex2 = DatabaseIndex(name, number) nameIndex3 = DatabaseIndex({'column': name, 'length': 3}) class SOIndex2(SQLObject): name = StringCol(length=100) nameIndex = DatabaseIndex({'expression': 'lower(name)'}) def test_indexes_1(): setupClass(SOIndex1) n = 0 for name in 'blah blech boring yep yort snort'.split(): n += 1 SOIndex1(name=name, number=n) mod = SOIndex1._connection.module raises( (mod.ProgrammingError, mod.IntegrityError, mod.OperationalError, mod.DatabaseError, ProgrammingError, IntegrityError, OperationalError, DatabaseError), SOIndex1, name='blah', number=0) def test_indexes_2(): if not supports('expressionIndex'): py.test.skip("expressionIndex isn't supported") setupClass(SOIndex2) SOIndex2(name='') class PersonIndexGet(SQLObject): firstName = StringCol(length=100) lastName = StringCol(length=100) age = IntCol(alternateID=True) nameIndex = DatabaseIndex(firstName, lastName, unique=True) def test_index_get_1(): setupClass(PersonIndexGet, force=True) PersonIndexGet(firstName='Eric', lastName='Idle', age=62) PersonIndexGet(firstName='Terry', lastName='Gilliam', age=65) PersonIndexGet(firstName='John', lastName='Cleese', age=66) PersonIndexGet.get(1) PersonIndexGet.nameIndex.get('Terry', 'Gilliam') PersonIndexGet.nameIndex.get(firstName='John', lastName='Cleese') raises(Exception, PersonIndexGet.nameIndex.get, firstName='Graham', lastName='Chapman') raises(Exception, PersonIndexGet.nameIndex.get, 'Terry', lastName='Gilliam') raises(Exception, PersonIndexGet.nameIndex.get, 'Terry', 'Gilliam', 65) raises(Exception, PersonIndexGet.nameIndex.get, 'Terry') class PersonIndexGet2(SQLObject): name = StringCol(alternateID=True, length=100) age = IntCol() addresses = MultipleJoin('AddressIndexGet2') class AddressIndexGet2(SQLObject): person = ForeignKey('PersonIndexGet2', notNone=True) type = StringCol(notNone=True, length=100) street = StringCol(notNone=True) pk = DatabaseIndex(person, type, unique=True) def test_index_get_2(): setupClass([PersonIndexGet2, AddressIndexGet2]) p = PersonIndexGet2(name='Terry Guilliam', age=64) AddressIndexGet2(person=p, type='home', street='Terry Street 234') AddressIndexGet2(person=p, type='work', street='Guilliam Street 234') AddressIndexGet2.pk.get(p, 'work') AddressIndexGet2.pk.get(person=p, type='work') SQLObject-3.1.0/sqlobject/tests/test_jsonbcol.py0000644000175000017500000000267612747416060021245 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject, JsonbCol from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # Jsonb columns ######################################## class JsonbContainer(SQLObject): jsondata = JsonbCol(default=None) jsondata_none = JsonbCol(default=None) jsondata_list = JsonbCol(default=None) dictdata = dict( ship=u'USS Voyager', number='NCC-74656', crew=['Cpt. Janeway', 'Doctor', 'Lt. Torries', 'Seven of Nine'], races=('Borg', 'Kason',), distance2earth=70000, coming_home=True) nonedata = None listofdictsdata = [dict(Erath=7390000000), dict(Vulcan=6000000000), dict(Kronos='unknown')] def test_jsonbCol(): connection = getConnection() if connection.dbName != "postgres": py.test.skip("These tests require PostgreSQL") setupClass([JsonbContainer], force=True) my_jsonb = JsonbContainer( jsondata=dictdata, jsondata_none=nonedata, jsondata_list=listofdictsdata) iid = my_jsonb.id JsonbContainer._connection.cache.clear() my_jsonb_2 = JsonbContainer.get(iid) assert my_jsonb_2.jsondata['coming_home'] == dictdata['coming_home'] assert my_jsonb_2.jsondata['crew'] == dictdata['crew'] assert my_jsonb_2.jsondata['races'] == ['Borg', 'Kason'] assert my_jsonb_2.jsondata_none is None assert my_jsonb_2.jsondata_list == listofdictsdata SQLObject-3.1.0/sqlobject/tests/dbtest.py0000644000175000017500000002532212753526731017657 0ustar phdphd00000000000000""" The framework for making database tests. """ from __future__ import print_function import logging import os import sys from py.test import raises, skip import sqlobject import sqlobject.conftest as conftest if sys.platform[:3] == "win": def getcwd(): return os.getcwd().replace('\\', '/') else: getcwd = os.getcwd """ supportsMatrix defines what database backends support what features. Each feature has a name, if you see a key like '+featureName' then only the databases listed support the feature. Conversely, '-featureName' means all databases *except* the ones listed support the feature. The databases are given by their SQLObject string name, separated by spaces. The function supports(featureName) returns True or False based on this, and you can use it like:: def test_featureX(): if not supports('featureX'): py.test.skip("Doesn't support featureX") """ supportsMatrix = { '+exceptions': 'mysql postgres sqlite', '-transactions': 'mysql rdbhost', '-dropTableCascade': 'sybase mssql mysql', '-expressionIndex': 'mysql sqlite firebird mssql', '-blobData': 'mssql rdbhost', '-decimalColumn': 'mssql', '-emptyTable': 'mssql', '-limitSelect': 'mssql', '+schema': 'postgres', '+memorydb': 'sqlite', } def setupClass(soClasses, force=False): """ Makes sure the classes have a corresponding and correct table. This won't recreate the table if it already exists. It will check that the table is properly defined (in case you change your table definition). You can provide a single class or a list of classes; if a list then classes will be created in the order you provide, and destroyed in the opposite order. So if class A depends on class B, then do setupClass([B, A]) and B won't be destroyed or cleared until after A is destroyed or cleared. If force is true, then the database will be recreated no matter what. """ global hub if not isinstance(soClasses, (list, tuple)): soClasses = [soClasses] connection = getConnection() for soClass in soClasses: # This would be an alternate way to register connections: # try: # hub # except NameError: # hub = sqlobject.dbconnection.ConnectionHub() # soClass._connection = hub # hub.threadConnection = connection # hub.processConnection = connection soClass._connection = connection installOrClear(soClasses, force=force) return soClasses def speedupSQLiteConnection(connection): connection.query("PRAGMA synchronous=OFF") connection.query("PRAGMA count_changes=OFF") connection.query("PRAGMA journal_mode=MEMORY") connection.query("PRAGMA temp_store=MEMORY") installedDBFilename = os.path.join(getcwd(), 'dbs_data.tmp') installedDBTracker = sqlobject.connectionForURI( 'sqlite:///' + installedDBFilename) speedupSQLiteConnection(installedDBTracker) def getConnection(**kw): name = getConnectionURI() conn = sqlobject.connectionForURI(name, **kw) if conftest.option.show_sql: conn.debug = True if conftest.option.show_sql_output: conn.debugOutput = True if conn.dbName == 'sqlite': speedupSQLiteConnection(conn) return conn def getConnectionURI(): name = conftest.option.Database if name in conftest.connectionShortcuts: name = conftest.connectionShortcuts[name] return name try: connection = getConnection() except Exception as e: # At least this module should be importable... # The module was imported during documentation building if 'pudge' not in sys.modules: print("Could not open database: %s" % e, file=sys.stderr) class InstalledTestDatabase(sqlobject.SQLObject): """ This table is set up in SQLite (always, regardless of --Database) and tracks what tables have been set up in the 'real' database. This way we don't keep recreating the tables over and over when there are multiple tests that use a table. """ _connection = installedDBTracker table_name = sqlobject.StringCol(notNull=True) createSQL = sqlobject.StringCol(notNull=True) connectionURI = sqlobject.StringCol(notNull=True) @classmethod def installOrClear(cls, soClasses, force=False): cls.setup() reversed = list(soClasses)[:] reversed.reverse() # If anything needs to be dropped, they all must be dropped # But if we're forcing it, then we'll always drop if force: any_drops = True else: any_drops = False for soClass in reversed: table = soClass.sqlmeta.table if not soClass._connection.tableExists(table): continue items = list(cls.selectBy( table_name=table, connectionURI=soClass._connection.uri())) if items: instance = items[0] sql = instance.createSQL else: sql = None newSQL, constraints = soClass.createTableSQL() if sql != newSQL: if sql is not None: instance.destroySelf() any_drops = True break for soClass in reversed: if soClass._connection.tableExists(soClass.sqlmeta.table): if any_drops: cls.drop(soClass) else: cls.clear(soClass) for soClass in soClasses: table = soClass.sqlmeta.table if not soClass._connection.tableExists(table): cls.install(soClass) @classmethod def install(cls, soClass): """ Creates the given table in its database. """ sql = getattr(soClass, soClass._connection.dbName + 'Create', None) all_extra = [] if sql: soClass._connection.query(sql) else: sql, extra_sql = soClass.createTableSQL() soClass.createTable(applyConstraints=False) all_extra.extend(extra_sql) cls(table_name=soClass.sqlmeta.table, createSQL=sql, connectionURI=soClass._connection.uri()) for extra_sql in all_extra: soClass._connection.query(extra_sql) @classmethod def drop(cls, soClass): """ Drops a the given table from its database """ sql = getattr(soClass, soClass._connection.dbName + 'Drop', None) if sql: soClass._connection.query(sql) else: soClass.dropTable() @classmethod def clear(cls, soClass): """ Removes all the rows from a table. """ soClass.clearTable() @classmethod def setup(cls): """ This sets up *this* table. """ if not cls._connection.tableExists(cls.sqlmeta.table): cls.createTable() installOrClear = InstalledTestDatabase.installOrClear class Dummy(object): """ Used for creating fake objects; a really poor 'mock object'. """ def __init__(self, **kw): for name, value in kw.items(): setattr(self, name, value) def inserts(cls, data, schema=None): """ Creates a bunch of rows. You can use it like:: inserts(Person, [{'fname': 'blah', 'lname': 'doe'}, ...]) Or:: inserts(Person, [('blah', 'doe')], schema= ['fname', 'lname']) If you give a single string for the `schema` then it'll split that string to get the list of column names. """ if schema: if isinstance(schema, str): schema = schema.split() keywordData = [] for item in data: itemDict = {} for name, value in zip(schema, item): itemDict[name] = value keywordData.append(itemDict) data = keywordData results = [] for args in data: results.append(cls(**args)) return results def supports(feature): dbName = connection.dbName support = supportsMatrix.get('+' + feature, None) notSupport = supportsMatrix.get('-' + feature, None) if support is not None and dbName in support.split(): return True elif support: return False if notSupport is not None and dbName in notSupport.split(): return False elif notSupport: return True assert notSupport is not None or support is not None, ( "The supportMatrix does not list this feature: %r" % feature) # To avoid name clashes: _inserts = inserts def setSQLiteConnectionFactory(TableClass, factory): from sqlobject.sqlite.sqliteconnection import SQLiteConnection conn = TableClass._connection TableClass._connection = SQLiteConnection( filename=conn.filename, name=conn.name, debug=conn.debug, debugOutput=conn.debugOutput, cache=conn.cache, style=conn.style, autoCommit=conn.autoCommit, debugThreading=conn.debugThreading, registry=conn.registry, factory=factory ) speedupSQLiteConnection(TableClass._connection) installOrClear([TableClass]) def deprecated_module(): sqlobject.main.warnings_level = None sqlobject.main.exception_level = None def setup_module(mod): # modules with '_old' test backward compatible methods, so they # don't get warnings or errors. mod_name = str(mod.__name__) if mod_name.endswith('/py'): mod_name = mod_name[:-3] if mod_name.endswith('_old'): sqlobject.main.warnings_level = None sqlobject.main.exception_level = None else: sqlobject.main.warnings_level = None sqlobject.main.exception_level = 0 def teardown_module(mod=None): sqlobject.main.warnings_level = None sqlobject.main.exception_level = 0 def setupLogging(): fmt = '[%(asctime)s] %(name)s %(levelname)s: %(message)s' formatter = logging.Formatter(fmt) hdlr = logging.StreamHandler(sys.stderr) hdlr.setFormatter(formatter) hdlr.setLevel(logging.NOTSET) logger = logging.getLogger() logger.addHandler(hdlr) def setupCyclicClasses(*classes): if not supports('dropTableCascade'): skip("dropTableCascade isn't supported") conn = getConnection() for soClass in classes: soClass.setConnection(conn) soClass.dropTable(ifExists=True, cascade=True) constraints = [] for soClass in classes: constraints += soClass.createTable(ifNotExists=True, applyConstraints=False) for constraint in constraints: conn.query(constraint) __all__ = ['Dummy', 'deprecated_module', 'getConnection', 'getConnectionURI', 'inserts', 'raises', 'setupClass', 'setupCyclicClasses', 'setupLogging', 'setup_module', 'supports', 'teardown_module', ] SQLObject-3.1.0/sqlobject/tests/test_style.py0000644000175000017500000000175012747416060020564 0ustar phdphd00000000000000from sqlobject import ForeignKey, SQLObject, StringCol, sqlmeta, styles from sqlobject.tests.dbtest import setupClass class AnotherStyle(styles.MixedCaseUnderscoreStyle): def pythonAttrToDBColumn(self, attr): if attr.lower().endswith('id'): return 'id' + styles.MixedCaseUnderscoreStyle.\ pythonAttrToDBColumn(self, attr[:-2]) else: return styles.MixedCaseUnderscoreStyle.\ pythonAttrToDBColumn(self, attr) class SOStyleTest1(SQLObject): a = StringCol() st2 = ForeignKey('SOStyleTest2') class sqlmeta(sqlmeta): style = AnotherStyle() class SOStyleTest2(SQLObject): b = StringCol() class sqlmeta(sqlmeta): style = AnotherStyle() def test_style(): setupClass([SOStyleTest2, SOStyleTest1]) st1 = SOStyleTest1(a='something', st2=None) st2 = SOStyleTest2(b='whatever') st1.st2 = st2 assert st1.sqlmeta.columns['st2ID'].dbName == 'idst2' assert st1.st2 == st2 SQLObject-3.1.0/sqlobject/tests/test_picklecol.py0000644000175000017500000000216212747416060021367 0ustar phdphd00000000000000import py.test from sqlobject import PickleCol, SQLObject from sqlobject.tests.dbtest import setupClass, supports ######################################## # Pickle columns ######################################## class PickleData: pi = 3.14156 def __init__(self): self.question = \ 'The Ulimate Question of Life, the Universe and Everything' self.answer = 42 class PickleContainer(SQLObject): pickledata = PickleCol(default=None, length=65535) def test_pickleCol(): if not supports('blobData'): py.test.skip("blobData isn't supported") setupClass([PickleContainer], force=True) mypickledata = PickleData() ctnr = PickleContainer(pickledata=mypickledata) iid = ctnr.id PickleContainer._connection.cache.clear() ctnr2 = PickleContainer.get(iid) s2 = ctnr2.pickledata assert isinstance(s2, PickleData) assert isinstance(s2.pi, float) assert isinstance(s2.question, str) assert isinstance(s2.answer, int) assert s2.pi == mypickledata.pi assert s2.question == mypickledata.question assert s2.answer == mypickledata.answer SQLObject-3.1.0/sqlobject/tests/test_joins.py0000644000175000017500000001125612747416060020550 0ustar phdphd00000000000000from sqlobject import ForeignKey, MultipleJoin, RelatedJoin, SQLObject, \ StringCol from sqlobject.tests.dbtest import setupClass ######################################## # Joins ######################################## class PersonJoiner(SQLObject): name = StringCol(length=40, alternateID=True) addressJoiners = RelatedJoin('AddressJoiner') class AddressJoiner(SQLObject): zip = StringCol(length=5, alternateID=True) personJoiners = RelatedJoin('PersonJoiner') class ImplicitJoiningSO(SQLObject): foo = RelatedJoin('Bar') class ExplicitJoiningSO(SQLObject): foo = MultipleJoin('Bar', joinMethodName='foo') class TestJoin: def setup_method(self, meth): setupClass(PersonJoiner) setupClass(AddressJoiner) for n in ['bob', 'tim', 'jane', 'joe', 'fred', 'barb']: PersonJoiner(name=n) for z in ['11111', '22222', '33333', '44444']: AddressJoiner(zip=z) def test_join(self): b = PersonJoiner.byName('bob') assert b.addressJoiners == [] z = AddressJoiner.byZip('11111') b.addAddressJoiner(z) self.assertZipsEqual(b.addressJoiners, ['11111']) self.assertNamesEqual(z.personJoiners, ['bob']) z2 = AddressJoiner.byZip('22222') b.addAddressJoiner(z2) self.assertZipsEqual(b.addressJoiners, ['11111', '22222']) self.assertNamesEqual(z2.personJoiners, ['bob']) b.removeAddressJoiner(z) self.assertZipsEqual(b.addressJoiners, ['22222']) self.assertNamesEqual(z.personJoiners, []) def assertZipsEqual(self, zips, dest): assert [a.zip for a in zips] == dest def assertNamesEqual(self, people, dest): assert [p.name for p in people] == dest def test_joinAttributeWithUnderscores(self): # Make sure that the implicit setting of joinMethodName works assert hasattr(ImplicitJoiningSO, 'foo') assert not hasattr(ImplicitJoiningSO, 'bars') # And make sure explicit setting also works assert hasattr(ExplicitJoiningSO, 'foo') assert not hasattr(ExplicitJoiningSO, 'bars') class PersonJoiner2(SQLObject): name = StringCol('name', length=40, alternateID=True) addressJoiner2s = MultipleJoin('AddressJoiner2') class AddressJoiner2(SQLObject): class sqlmeta: defaultOrder = ['-zip', 'plus4'] zip = StringCol(length=5) plus4 = StringCol(length=4, default=None) personJoiner2 = ForeignKey('PersonJoiner2') class TestJoin2: def setup_method(self, meth): setupClass([PersonJoiner2, AddressJoiner2]) p1 = PersonJoiner2(name='bob') p2 = PersonJoiner2(name='sally') for z in ['11111', '22222', '33333']: AddressJoiner2(zip=z, personJoiner2=p1) AddressJoiner2(zip='00000', personJoiner2=p2) def test_basic(self): bob = PersonJoiner2.byName('bob') sally = PersonJoiner2.byName('sally') assert len(bob.addressJoiner2s) == 3 assert len(sally.addressJoiner2s) == 1 bob.addressJoiner2s[0].destroySelf() assert len(bob.addressJoiner2s) == 2 z = bob.addressJoiner2s[0] z.zip = 'xxxxx' id = z.id del z z = AddressJoiner2.get(id) assert z.zip == 'xxxxx' def test_defaultOrder(self): p1 = PersonJoiner2.byName('bob') assert ([i.zip for i in p1.addressJoiner2s] == ['33333', '22222', '11111']) _personJoiner3_getters = [] _personJoiner3_setters = [] class PersonJoiner3(SQLObject): name = StringCol('name', length=40, alternateID=True) addressJoiner3s = MultipleJoin('AddressJoiner3') class AddressJoiner3(SQLObject): zip = StringCol(length=5) personJoiner3 = ForeignKey('PersonJoiner3') def _get_personJoiner3(self): value = self._SO_get_personJoiner3() _personJoiner3_getters.append((self, value)) return value def _set_personJoiner3(self, value): self._SO_set_personJoiner3(value) _personJoiner3_setters.append((self, value)) class TestJoin3: def setup_method(self, meth): setupClass([PersonJoiner3, AddressJoiner3]) p1 = PersonJoiner3(name='bob') p2 = PersonJoiner3(name='sally') for z in ['11111', '22222', '33333']: AddressJoiner3(zip=z, personJoiner3=p1) AddressJoiner3(zip='00000', personJoiner3=p2) def test_accessors(self): assert len(_personJoiner3_getters) == 0 assert len(_personJoiner3_setters) == 4 bob = PersonJoiner3.byName('bob') for addressJoiner3 in bob.addressJoiner3s: addressJoiner3.personJoiner3 assert len(_personJoiner3_getters) == 3 assert len(_personJoiner3_setters) == 4 SQLObject-3.1.0/sqlobject/tests/test_mysql.py0000644000175000017500000000113312747416060020564 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject from sqlobject.tests.dbtest import getConnection, setupClass class TestSOListMySQL(SQLObject): pass def test_list_databases(): connection = getConnection() if connection.dbName != "mysql": py.test.skip("These tests require MySQL") assert connection.db in connection.listDatabases() def test_list_tables(): connection = getConnection() if connection.dbName != "mysql": py.test.skip("These tests require MySQL") setupClass(TestSOListMySQL) assert TestSOListMySQL.sqlmeta.table in connection.listTables() SQLObject-3.1.0/sqlobject/tests/test_subqueries.py0000644000175000017500000001017312747416060021612 0ustar phdphd00000000000000from sqlobject import ForeignKey, SQLObject, StringCol from sqlobject.sqlbuilder import EXISTS, IN, LEFTOUTERJOINOn, NOTEXISTS, \ Outer, Select from sqlobject.tests.dbtest import setupClass ######################################## # Subqueries (subselects) ######################################## class TestIn1(SQLObject): col1 = StringCol() class TestIn2(SQLObject): col2 = StringCol() class TestOuter(SQLObject): fk = ForeignKey('TestIn1') def setup(): setupClass(TestIn1) setupClass(TestIn2) def insert(): setup() TestIn1(col1=None) TestIn1(col1='') TestIn1(col1="test") TestIn2(col2=None) TestIn2(col2='') TestIn2(col2="test") def test_1syntax_in(): setup() select = TestIn1.select(IN(TestIn1.q.col1, Select(TestIn2.q.col2))) assert str(select) == \ "SELECT test_in1.id, test_in1.col1 " \ "FROM test_in1 WHERE test_in1.col1 IN " \ "(SELECT test_in2.col2 FROM test_in2)" select = TestIn1.select(IN(TestIn1.q.col1, TestIn2.select())) assert str(select) == \ "SELECT test_in1.id, test_in1.col1 " \ "FROM test_in1 WHERE test_in1.col1 IN " \ "(SELECT test_in2.id FROM test_in2 WHERE 1 = 1)" def test_2perform_in(): insert() select = TestIn1.select(IN(TestIn1.q.col1, Select(TestIn2.q.col2))) assert select.count() == 2 def test_3syntax_exists(): setup() select = TestIn1.select(NOTEXISTS( Select(TestIn2.q.col2, where=(Outer(TestIn1).q.col1 == TestIn2.q.col2)))) assert str(select) == \ "SELECT test_in1.id, test_in1.col1 " \ "FROM test_in1 WHERE NOT EXISTS " \ "(SELECT test_in2.col2 FROM test_in2 " \ "WHERE ((test_in1.col1) = (test_in2.col2)))" setupClass(TestOuter) select = TestOuter.select(NOTEXISTS( Select(TestIn1.q.col1, where=(Outer(TestOuter).q.fk == TestIn1.q.id)))) assert str(select) == \ "SELECT test_outer.id, test_outer.fk_id " \ "FROM test_outer WHERE NOT EXISTS " \ "(SELECT test_in1.col1 FROM test_in1 " \ "WHERE ((test_outer.fk_id) = (test_in1.id)))" def test_4perform_exists(): insert() select = TestIn1.select(EXISTS( Select(TestIn2.q.col2, where=(Outer(TestIn1).q.col1 == TestIn2.q.col2)))) assert len(list(select)) == 2 setupClass(TestOuter) select = TestOuter.select(NOTEXISTS( Select(TestIn1.q.col1, where=(Outer(TestOuter).q.fkID == TestIn1.q.id)))) assert len(list(select)) == 0 def test_4syntax_direct(): setup() select = TestIn1.select(TestIn1.q.col1 == Select(TestIn2.q.col2, where=(TestIn2.q.col2 == "test"))) assert str(select) == \ "SELECT test_in1.id, test_in1.col1 " \ "FROM test_in1 WHERE ((test_in1.col1) = " \ "(SELECT test_in2.col2 FROM test_in2 " \ "WHERE ((test_in2.col2) = ('test'))))" def test_4perform_direct(): insert() select = TestIn1.select(TestIn1.q.col1 == Select(TestIn2.q.col2, where=(TestIn2.q.col2 == "test"))) assert select.count() == 1 def test_5perform_direct(): insert() select = TestIn1.select(TestIn1.q.col1 == Select(TestIn2.q.col2, where=(TestIn2.q.col2 == "test"))) assert select.count() == 1 def test_6syntax_join(): insert() j = LEFTOUTERJOINOn(TestIn2, TestIn1, TestIn1.q.col1 == TestIn2.q.col2) select = TestIn1.select(TestIn1.q.col1 == Select(TestIn2.q.col2, where=(TestIn2.q.col2 == "test"), join=j)) assert str(select) == \ "SELECT test_in1.id, test_in1.col1 " \ "FROM test_in1 WHERE ((test_in1.col1) = " \ "(SELECT test_in2.col2 FROM test_in2 " \ "LEFT OUTER JOIN test_in1 ON ((test_in1.col1) = (test_in2.col2)) " \ "WHERE ((test_in2.col2) = ('test'))))" def test_6perform_join(): insert() j = LEFTOUTERJOINOn(TestIn2, TestIn1, TestIn1.q.col1 == TestIn2.q.col2) select = TestIn1.select(TestIn1.q.col1 == Select(TestIn2.q.col2, where=(TestIn2.q.col2 == "test"), join=j)) assert select.count() == 1 SQLObject-3.1.0/sqlobject/tests/test_uuidcol.py0000644000175000017500000000113012747416060021060 0ustar phdphd00000000000000from uuid import UUID from sqlobject import SQLObject, UuidCol from sqlobject.tests.dbtest import setupClass ######################################## # Uuid columns ######################################## testuuid = UUID('7e3b5c1e-3402-4b10-a3c6-8ee6dbac7d1a') class UuidContainer(SQLObject): uuiddata = UuidCol(default=None) def test_uuidCol(): setupClass([UuidContainer], force=True) my_uuid = UuidContainer(uuiddata=testuuid) iid = my_uuid.id UuidContainer._connection.cache.clear() my_uuid_2 = UuidContainer.get(iid) assert my_uuid_2.uuiddata == testuuid SQLObject-3.1.0/sqlobject/tests/test_asdict.py0000644000175000017500000000071312747416060020671 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import setupClass ######################################## # sqlmeta.asDict() ######################################## class TestAsDict(SQLObject): name = StringCol(length=10) name2 = StringCol(length=10) def test_asDict(): setupClass(TestAsDict, force=True) t1 = TestAsDict(name='one', name2='1') assert t1.sqlmeta.asDict() == dict(name='one', name2='1', id=1) SQLObject-3.1.0/sqlobject/tests/test_sqlmeta_idName.py0000644000175000017500000000235112747416060022345 0ustar phdphd00000000000000from sqlobject import MixedCaseStyle, SQLObject, sqlmeta from sqlobject.tests.dbtest import setupClass class myid_sqlmeta(sqlmeta): idName = "my_id" class TestSqlmeta1(SQLObject): class sqlmeta(myid_sqlmeta): pass class TestSqlmeta2(SQLObject): class sqlmeta(sqlmeta): style = MixedCaseStyle(longID=True) class TestSqlmeta3(SQLObject): class sqlmeta(myid_sqlmeta): style = MixedCaseStyle(longID=True) class TestSqlmeta4(SQLObject): class sqlmeta(myid_sqlmeta): idName = None style = MixedCaseStyle(longID=True) class longid_sqlmeta(sqlmeta): idName = "my_id" style = MixedCaseStyle(longID=True) class TestSqlmeta5(SQLObject): class sqlmeta(longid_sqlmeta): pass class TestSqlmeta6(SQLObject): class sqlmeta(longid_sqlmeta): idName = None def test_sqlmeta_inherited_idName(): setupClass([TestSqlmeta1, TestSqlmeta2]) assert TestSqlmeta1.sqlmeta.idName == "my_id" assert TestSqlmeta2.sqlmeta.idName == "TestSqlmeta2ID" assert TestSqlmeta3.sqlmeta.idName == "my_id" assert TestSqlmeta4.sqlmeta.idName == "TestSqlmeta4ID" assert TestSqlmeta5.sqlmeta.idName == "my_id" assert TestSqlmeta6.sqlmeta.idName == "TestSqlmeta6ID" SQLObject-3.1.0/sqlobject/tests/test_joins_conditional.py0000644000175000017500000000730512747416060023133 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.sqlbuilder import JOIN, LEFTJOIN, LEFTJOINConditional, \ LEFTJOINOn, LEFTJOINUsing from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # Condiotional joins ######################################## class TestJoin1(SQLObject): col1 = StringCol() class TestJoin2(SQLObject): col2 = StringCol() class TestJoin3(SQLObject): col3 = StringCol() class TestJoin4(SQLObject): col4 = StringCol() class TestJoin5(SQLObject): col5 = StringCol() def setup(): setupClass(TestJoin1) setupClass(TestJoin2) def test_1syntax(): setup() join = JOIN("table1", "table2") assert str(join) == "table1 JOIN table2" join = LEFTJOIN("table1", "table2") assert str(join) == "table1 LEFT JOIN table2" join = LEFTJOINOn("table1", "table2", "tabl1.col1 = table2.col2") assert getConnection().sqlrepr(join) == \ "table1 LEFT JOIN table2 ON tabl1.col1 = table2.col2" def test_2select_syntax(): setup() select = TestJoin1.select( join=LEFTJOINConditional(TestJoin1, TestJoin2, on_condition=( TestJoin1.q.col1 == TestJoin2.q.col2)) ) assert str(select) == \ "SELECT test_join1.id, test_join1.col1 " \ "FROM test_join1 " \ "LEFT JOIN test_join2 " \ "ON ((test_join1.col1) = (test_join2.col2)) WHERE 1 = 1" def test_3perform_join(): setup() TestJoin1(col1="test1") TestJoin1(col1="test2") TestJoin1(col1="test3") TestJoin2(col2="test1") TestJoin2(col2="test2") select = TestJoin1.select( join=LEFTJOINOn(TestJoin1, TestJoin2, TestJoin1.q.col1 == TestJoin2.q.col2) ) assert select.count() == 3 def test_4join_3tables_syntax(): setup() setupClass(TestJoin3) select = TestJoin1.select( join=LEFTJOIN(TestJoin2, TestJoin3) ) assert str(select) == \ "SELECT test_join1.id, test_join1.col1 " \ "FROM test_join1, test_join2 LEFT JOIN test_join3 WHERE 1 = 1" def test_5join_3tables_syntax2(): setup() setupClass(TestJoin3) select = TestJoin1.select( join=(LEFTJOIN(None, TestJoin2), LEFTJOIN(None, TestJoin3)) ) assert str(select) == \ "SELECT test_join1.id, test_join1.col1 " \ "FROM test_join1 " \ "LEFT JOIN test_join2 LEFT JOIN test_join3 WHERE 1 = 1" select = TestJoin1.select( join=(LEFTJOIN(TestJoin1, TestJoin2), LEFTJOIN(TestJoin1, TestJoin3)) ) assert str(select) == \ "SELECT test_join1.id, test_join1.col1 " \ "FROM test_join1 " \ "LEFT JOIN test_join2, test_join1 LEFT JOIN test_join3 WHERE 1 = 1" def test_6join_using(): setup() setupClass(TestJoin3) select = TestJoin1.select( join=LEFTJOINUsing(None, TestJoin2, [TestJoin2.q.id]) ) assert str(select) == \ "SELECT test_join1.id, test_join1.col1 " \ "FROM test_join1 " \ "LEFT JOIN test_join2 USING (test_join2.id) WHERE 1 = 1" def test_7join_on(): setup() setupClass(TestJoin3) setupClass(TestJoin4) setupClass(TestJoin5) select = TestJoin1.select(join=( LEFTJOINOn(TestJoin2, TestJoin3, TestJoin2.q.col2 == TestJoin3.q.col3), LEFTJOINOn(TestJoin4, TestJoin5, TestJoin4.q.col4 == TestJoin5.q.col5) )) assert str(select) == \ "SELECT test_join1.id, test_join1.col1 " \ "FROM test_join1, test_join2 " \ "LEFT JOIN test_join3 " \ "ON ((test_join2.col2) = (test_join3.col3)), test_join4 " \ "LEFT JOIN test_join5 " \ "ON ((test_join4.col4) = (test_join5.col5)) WHERE 1 = 1" SQLObject-3.1.0/sqlobject/tests/test_delete.py0000644000175000017500000000337012747416060020666 0ustar phdphd00000000000000from sqlobject import OR, RelatedJoin, SQLObject, StringCol, cache from sqlobject.tests.dbtest import setupClass from .test_basic import TestSO1, setupGetters ######################################## # Delete during select ######################################## def testSelect(): setupGetters(TestSO1) for obj in TestSO1.select('all'): obj.destroySelf() assert list(TestSO1.select('all')) == [] ######################################## # Delete many rows at once ######################################## def testDeleteMany(): setupGetters(TestSO1) TestSO1.deleteMany(OR(TestSO1.q.name == "bob", TestSO1.q.name == "fred")) assert len(list(TestSO1.select('all'))) == 2 def testDeleteBy(): setupGetters(TestSO1) TestSO1.deleteBy(name="dave") assert len(list(TestSO1.select())) == 3 ######################################## # Delete without caching ######################################## class NoCache(SQLObject): name = StringCol() def testDestroySelf(): setupClass(NoCache) old = NoCache._connection.cache NoCache._connection.cache = cache.CacheSet(cache=False) value = NoCache(name='test') value.destroySelf() NoCache._connection.cache = old ######################################## # Delete from related joins ######################################## class Service(SQLObject): groups = RelatedJoin("ServiceGroup") class ServiceGroup(SQLObject): services = RelatedJoin("Service") def testDeleteRelatedJoins(): setupClass([Service, ServiceGroup]) service = Service() service_group = ServiceGroup() service.addServiceGroup(service_group) service.destroySelf() service_group = ServiceGroup.get(service_group.id) assert len(service_group.services) == 0 SQLObject-3.1.0/sqlobject/tests/test_postgres.py0000644000175000017500000000264312747416060021274 0ustar phdphd00000000000000import py.test from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # Test PosgreSQL sslmode ######################################## class TestSSLMode(SQLObject): test = StringCol() def test_sslmode(): setupClass(TestSSLMode) connection = TestSSLMode._connection if (connection.dbName != 'postgres') or \ (not connection.module.__name__.startswith('psycopg')): py.test.skip("The test requires PostgreSQL, psycopg and ssl mode") connection = getConnection(sslmode='require') TestSSLMode._connection = connection test = TestSSLMode(test='test') # Connect to the DB to test sslmode connection.cache.clear() test = TestSSLMode.select()[0] assert test.test == 'test' ######################################## # Test PosgreSQL list{Database,Tables} ######################################## class TestSOList(SQLObject): pass def test_list_databases(): connection = getConnection() if connection.dbName != "postgres": py.test.skip("These tests require PostgreSQL") assert connection.db in connection.listDatabases() def test_list_tables(): connection = getConnection() if connection.dbName != "postgres": py.test.skip("These tests require PostgreSQL") setupClass(TestSOList) assert TestSOList.sqlmeta.table in connection.listTables() SQLObject-3.1.0/sqlobject/tests/test_boundattributes.py0000644000175000017500000000306412470110264022630 0ustar phdphd00000000000000import py.test from sqlobject import boundattributes from sqlobject import declarative pytestmark = py.test.mark.skipif('True') class TestMe(object): pass class AttrReplace(boundattributes.BoundAttribute): __unpackargs__ = ('replace',) replace = None @declarative.classinstancemethod def make_object(self, cls, added_class, attr_name, **attrs): if not self: return cls.singleton().make_object( added_class, attr_name, **attrs) self.replace.added_class = added_class self.replace.name = attr_name assert attrs['replace'] is self.replace del attrs['replace'] self.replace.attrs = attrs return self.replace class Holder: def __init__(self, name): self.holder_name = name def __repr__(self): return '' % self.holder_name def test_1(): v1 = Holder('v1') v2 = Holder('v2') v3 = Holder('v3') class V2Class(AttrReplace): arg1 = 'nothing' arg2 = ['something'] class A1(TestMe): a = AttrReplace(v1) v = V2Class(v2) class inline(AttrReplace): replace = v3 arg3 = 'again' arg4 = 'so there' for n in ('a', 'v', 'inline'): assert getattr(A1, n).name == n assert getattr(A1, n).added_class is A1 assert A1.a is v1 assert A1.a.attrs == {} assert A1.v is v2 assert A1.v.attrs == {'arg1': 'nothing', 'arg2': ['something']} assert A1.inline is v3 assert A1.inline.attrs == {'arg3': 'again', 'arg4': 'so there'} SQLObject-3.1.0/sqlobject/tests/test_sqlite.py0000644000175000017500000001077612747416060020735 0ustar phdphd00000000000000import threading import py.test from sqlobject import SQLObject, StringCol from sqlobject.compat import string_type from sqlobject.tests.dbtest import getConnection, setupClass, supports from sqlobject.tests.dbtest import setSQLiteConnectionFactory from .test_basic import TestSO1 class SQLiteFactoryTest(SQLObject): name = StringCol() def test_sqlite_factory(): setupClass(SQLiteFactoryTest) if SQLiteFactoryTest._connection.dbName != "sqlite": py.test.skip("These tests require SQLite") if not SQLiteFactoryTest._connection.using_sqlite2: py.test.skip("These tests require SQLite v2+") factory = [None] def SQLiteConnectionFactory(sqlite): class MyConnection(sqlite.Connection): pass factory[0] = MyConnection return MyConnection setSQLiteConnectionFactory(SQLiteFactoryTest, SQLiteConnectionFactory) conn = SQLiteFactoryTest._connection.makeConnection() assert factory[0] assert isinstance(conn, factory[0]) def test_sqlite_factory_str(): setupClass(SQLiteFactoryTest) if SQLiteFactoryTest._connection.dbName != "sqlite": py.test.skip("These tests require SQLite") if not SQLiteFactoryTest._connection.using_sqlite2: py.test.skip("These tests require SQLite v2+") factory = [None] def SQLiteConnectionFactory(sqlite): class MyConnection(sqlite.Connection): pass factory[0] = MyConnection return MyConnection from sqlobject.sqlite import sqliteconnection sqliteconnection.SQLiteConnectionFactory = SQLiteConnectionFactory setSQLiteConnectionFactory(SQLiteFactoryTest, "SQLiteConnectionFactory") conn = SQLiteFactoryTest._connection.makeConnection() assert factory[0] assert isinstance(conn, factory[0]) del sqliteconnection.SQLiteConnectionFactory def test_sqlite_aggregate(): setupClass(SQLiteFactoryTest) if SQLiteFactoryTest._connection.dbName != "sqlite": py.test.skip("These tests require SQLite") if not SQLiteFactoryTest._connection.using_sqlite2: py.test.skip("These tests require SQLite v2+") def SQLiteConnectionFactory(sqlite): class MyConnection(sqlite.Connection): def __init__(self, *args, **kwargs): super(MyConnection, self).__init__(*args, **kwargs) self.create_aggregate("group_concat", 1, self.group_concat) class group_concat: def __init__(self): self.acc = [] def step(self, value): if isinstance(value, string_type): self.acc.append(value) else: self.acc.append(str(value)) def finalize(self): self.acc.sort() return ", ".join(self.acc) return MyConnection setSQLiteConnectionFactory(SQLiteFactoryTest, SQLiteConnectionFactory) SQLiteFactoryTest(name='sqlobject') SQLiteFactoryTest(name='sqlbuilder') assert SQLiteFactoryTest.select(orderBy="name").\ accumulateOne("group_concat", "name") == \ "sqlbuilder, sqlobject" def do_select(): list(TestSO1.select()) def test_sqlite_threaded(): setupClass(TestSO1) t = threading.Thread(target=do_select) t.start() t.join() # This should reuse the same connection as the connection # made above (at least will with most database drivers, but # this will cause an error in SQLite): do_select() def test_empty_string(): setupClass(TestSO1) test = TestSO1(name=None, passwd='') assert test.name is None assert test.passwd == '' def test_memorydb(): if not supports("memorydb"): py.test.skip("memorydb isn't supported") connection = getConnection() if connection.dbName != "sqlite": py.test.skip("These tests require SQLite") if not connection._memory: py.test.skip("The connection isn't memorydb") setupClass(TestSO1) connection.close() # create a new connection to an in-memory database TestSO1.setConnection(connection) TestSO1.createTable() def test_list_databases(): connection = getConnection() if connection.dbName != "sqlite": py.test.skip("These tests require SQLite") assert connection.listDatabases() == ['main'] def test_list_tables(): connection = getConnection() if connection.dbName != "sqlite": py.test.skip("These tests require SQLite") setupClass(TestSO1) assert TestSO1.sqlmeta.table in connection.listTables() SQLObject-3.1.0/sqlobject/tests/test_distinct.py0000644000175000017500000000151312747416060021242 0ustar phdphd00000000000000from sqlobject import ForeignKey, IntCol, SQLObject from sqlobject.tests.dbtest import setupClass ######################################## # Distinct ######################################## class Distinct1(SQLObject): n = IntCol() class Distinct2(SQLObject): other = ForeignKey('Distinct1') def count(select): result = {} for ob in select: result[int(ob.n)] = result.get(int(ob.n), 0) + 1 return result def test_distinct(): setupClass([Distinct1, Distinct2]) obs = [Distinct1(n=i) for i in range(3)] Distinct2(other=obs[0]) Distinct2(other=obs[0]) Distinct2(other=obs[1]) query = (Distinct2.q.otherID == Distinct1.q.id) sel = Distinct1.select(query) assert count(sel) == {0: 2, 1: 1} sel = Distinct1.select(query, distinct=True) assert count(sel) == {0: 1, 1: 1} SQLObject-3.1.0/sqlobject/tests/test_aliases.py0000644000175000017500000000305512747416060021045 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.sqlbuilder import Alias, LEFTJOINOn from sqlobject.tests.dbtest import setupClass ######################################## # Table aliases and self-joins ######################################## class JoinAlias(SQLObject): name = StringCol() parent = StringCol() def test_1syntax(): setupClass(JoinAlias) alias = Alias(JoinAlias) select = JoinAlias.select(JoinAlias.q.parent == alias.q.name) assert str(select) == \ "SELECT join_alias.id, join_alias.name, join_alias.parent " \ "FROM join_alias, join_alias join_alias_alias1 " \ "WHERE ((join_alias.parent) = (join_alias_alias1.name))" def test_2perform_join(): setupClass(JoinAlias) JoinAlias(name="grandparent", parent=None) JoinAlias(name="parent", parent="grandparent") JoinAlias(name="child", parent="parent") alias = Alias(JoinAlias) select = JoinAlias.select(JoinAlias.q.parent == alias.q.name) assert select.count() == 2 def test_3joins(): setupClass(JoinAlias) alias = Alias(JoinAlias) select = JoinAlias.select( (JoinAlias.q.name == 'a') & (alias.q.name == 'b'), join=LEFTJOINOn(None, alias, alias.q.name == 'c') ) assert str(select) == \ "SELECT join_alias.id, join_alias.name, join_alias.parent " \ "FROM join_alias " \ "LEFT JOIN join_alias join_alias_alias3 " \ "ON ((join_alias_alias3.name) = ('c')) " \ "WHERE (((join_alias.name) = ('a')) AND " \ "((join_alias_alias3.name) = ('b')))" SQLObject-3.1.0/sqlobject/tests/test_sqlbuilder_joins_instances.py0000644000175000017500000000572612747416060025052 0ustar phdphd00000000000000from sqlobject import AND, ForeignKey, SQLMultipleJoin, SQLObject, \ SQLRelatedJoin, StringCol from sqlobject.tests.dbtest import inserts, setupClass # Testing for expressing join, foreign keys, # and instance identity in SQLBuilder expressions. class SBPerson(SQLObject): name = StringCol() addresses = SQLMultipleJoin('SBAddress', joinColumn='personID') sharedAddresses = SQLRelatedJoin('SBAddress', addRemoveName='SharedAddress') class SBAddress(SQLObject): city = StringCol() person = ForeignKey('SBPerson') sharedPeople = SQLRelatedJoin('SBPerson') def setup_module(mod): global ppl setupClass([SBPerson, SBAddress]) ppl = inserts(SBPerson, [('James',), ('Julia',)], 'name') adds = inserts(SBAddress, [('London', ppl[0].id), ('Chicago', ppl[1].id), ('Abu Dhabi', ppl[1].id)], 'city personID') ppl[0].addSharedAddress(adds[0]) ppl[0].addSharedAddress(adds[1]) ppl[1].addSharedAddress(adds[0]) def testJoin(): assert list(SBPerson.select( AND(SBPerson.q.id == SBAddress.q.personID, SBAddress.q.city == 'London'))) == \ list(SBAddress.selectBy(city='London').throughTo.person) assert list(SBAddress.select( AND(SBPerson.q.id == SBAddress.q.personID, SBPerson.q.name == 'Julia')).orderBy(SBAddress.q.city)) == \ list(SBPerson.selectBy(name='Julia'). throughTo.addresses.orderBy(SBAddress.q.city)) def testRelatedJoin(): assert list(SBPerson.selectBy(name='Julia').throughTo.sharedAddresses) == \ list(ppl[1].sharedAddresses) def testInstance(): assert list(SBAddress.select( AND(SBPerson.q.id == SBAddress.q.personID, SBPerson.q.id == ppl[0].id) )) == list(ppl[0].addresses) def testFK(): assert list(SBPerson.select( AND(SBAddress.j.person, SBAddress.q.city == 'London'))) == \ list(SBPerson.select( AND(SBPerson.q.id == SBAddress.q.personID, SBAddress.q.city == 'London'))) def testRelatedJoin2(): assert list(SBAddress.select( AND(SBAddress.j.sharedPeople, SBPerson.q.name == 'Julia'))) == \ list(SBPerson.select( SBPerson.q.name == 'Julia').throughTo.sharedAddresses) def testJoin2(): assert list(SBAddress.select( AND(SBPerson.j.addresses, SBPerson.q.name == 'Julia')).orderBy(SBAddress.q.city)) == \ list(SBAddress.select( AND(SBPerson.q.id == SBAddress.q.personID, SBPerson.q.name == 'Julia')).orderBy(SBAddress.q.city)) == \ list(SBPerson.selectBy(name='Julia').throughTo. addresses.orderBy(SBAddress.q.city)) def testFK2(): assert list(SBAddress.select( AND(SBAddress.j.person, SBPerson.q.name == 'Julia'))) == \ list(SBAddress.select( AND(SBPerson.q.id == SBAddress.q.personID, SBPerson.q.name == 'Julia'))) SQLObject-3.1.0/sqlobject/tests/test_combining_joins.py0000644000175000017500000000250412747416060022571 0ustar phdphd00000000000000from sqlobject import ForeignKey, ManyToMany, OneToMany, SQLObject, StringCol from .dbtest import setupClass class ComplexGroup(SQLObject): name = StringCol() complexes = OneToMany('Complex') def _get_unit_models(self): q = self.complexes.clause & Complex.unit_models.clause return UnitModel.select(q) class Complex(SQLObject): name = StringCol() unit_models = ManyToMany('UnitModel') complex_group = ForeignKey('ComplexGroup') class UnitModel(SQLObject): class sqlmeta: defaultOrderBy = 'name' name = StringCol() complexes = ManyToMany('Complex') def test_join_sqlrepr(): setupClass([ComplexGroup, UnitModel, Complex]) cg1 = ComplexGroup(name='cg1') cg2 = ComplexGroup(name='cg2') c1 = Complex(name='c1', complex_group=cg1) c2 = Complex(name='c2', complex_group=cg2) c3 = Complex(name='c3', complex_group=cg2) u1 = UnitModel(name='u1') u2 = UnitModel(name='u2') u1.complexes.add(c1) u1.complexes.add(c2) u2.complexes.add(c2) u2.complexes.add(c3) assert list(Complex.selectBy(name='c1')) == [c1] assert list(cg1.unit_models) == [u1] assert list(cg2.unit_models) == [u1, u2, u2] assert list(cg2.unit_models.distinct()) == [u1, u2] assert list( cg2.unit_models.filter(UnitModel.q.name == 'u1')) == [u1] SQLObject-3.1.0/sqlobject/tests/test_paste.py0000644000175000017500000000454012747416060020540 0ustar phdphd00000000000000from __future__ import print_function import py.test from sqlobject import sqlhub, SQLObject, StringCol try: from sqlobject.wsgi_middleware import make_middleware except ImportError: pytestmark = py.test.mark.skipif('True') from .dbtest import getConnection, getConnectionURI, setupClass class NameOnly(SQLObject): name = StringCol() def makeapp(abort=False, begin=False, fail=False): def app(environ, start_response): NameOnly(name='app1') if fail == 'early': assert 0 start_response('200 OK', [('content-type', 'text/plain')]) if begin: environ['sqlobject.begin']() NameOnly(name='app2') if abort: environ['sqlobject.abort']() if fail: assert 0 return ['ok'] return app def makestack(abort=False, begin=False, fail=False, **kw): app = makeapp(abort=abort, begin=begin, fail=fail) app = make_middleware(app, {}, database=getConnectionURI(), **kw) return app def runapp(**kw): print('-' * 8) app = makestack(**kw) env = {} def start_response(*args): pass try: list(app(env, start_response)) return True except AssertionError: return False def setup(): setupClass(NameOnly) getConnection().query('DELETE FROM name_only') NameOnly._connection = sqlhub def names(): names = [n.name for n in NameOnly.select(connection=getConnection())] names.sort() return names def test_fail(): setup() assert not runapp(fail=True, use_transaction=True) assert names() == [] setup() assert not runapp(fail=True, use_transaction=False) assert names() == ['app1', 'app2'] setup() assert not runapp(fail=True, begin=True, use_transaction=True) assert names() == ['app1'] def test_other(): setup() assert runapp(fail=False, begin=True, use_transaction=True) assert names() == ['app1', 'app2'] setup() # @@: Dammit, I can't get these to pass because I can't get the # stupid table to clear itself. setupClass() sucks. When I # fix it I'll take this disabling out: py.test.skip("Oops...") assert names() == [] assert runapp(fail=False, begin=True, abort=True, use_transaction=True) assert names() == ['app1'] setup() assert runapp(use_transaction=True) assert names() == ['app1', 'app2'] SQLObject-3.1.0/sqlobject/tests/test_events.py0000644000175000017500000000650612747416060020734 0ustar phdphd00000000000000from __future__ import print_function from sqlobject import IntCol, SQLObject, StringCol, events from sqlobject.inheritance import InheritableSQLObject from sqlobject.tests.dbtest import setupClass class EventTester(SQLObject): name = StringCol() def make_watcher(): log = [] def watch(*args): log.append(args) watch.log = log return watch def make_listen(signal, cls=None): if cls is None: cls = EventTester watcher = make_watcher() events.listen(watcher, cls, signal) return watcher def test_create(): watcher = make_listen(events.ClassCreateSignal) class EventTesterSub1(EventTester): pass class EventTesterSub2(EventTesterSub1): pass assert len(watcher.log) == 2 assert len(watcher.log[0]) == 5 assert watcher.log[0][0] == 'EventTesterSub1' assert watcher.log[0][1] == (EventTester,) assert isinstance(watcher.log[0][2], dict) assert isinstance(watcher.log[0][3], list) def test_row_create(): setupClass(EventTester) watcher = make_listen(events.RowCreateSignal) row1 = EventTester(name='foo') row2 = EventTester(name='bar') assert len(watcher.log) == 2 assert watcher.log == [ (row1, {'name': 'foo'}, []), (row2, {'name': 'bar'}, [])] def test_row_destroy(): setupClass(EventTester) watcher = make_listen(events.RowDestroySignal) f = EventTester(name='foo') assert not watcher.log f.destroySelf() assert watcher.log == [(f, [])] def test_row_destroyed(): setupClass(EventTester) watcher = make_listen(events.RowDestroyedSignal) f = EventTester(name='foo') assert not watcher.log f.destroySelf() assert watcher.log == [(f, [])] def test_row_update(): setupClass(EventTester) watcher = make_listen(events.RowUpdateSignal) f = EventTester(name='bar') assert not watcher.log f.name = 'bar2' f.set(name='bar3') assert watcher.log == [ (f, {'name': 'bar2'}), (f, {'name': 'bar3'})] def test_row_updated(): setupClass(EventTester) watcher = make_listen(events.RowUpdatedSignal) f = EventTester(name='bar') assert not watcher.log f.name = 'bar2' f.set(name='bar3') assert watcher.log == [(f, []), (f, [])] def test_add_column(): setupClass(EventTester) watcher = make_listen(events.AddColumnSignal) events.summarize_events_by_sender() class NewEventTester(EventTester): name2 = StringCol() expect = ( NewEventTester, None, 'name2', NewEventTester.sqlmeta.columnDefinitions['name2'], False, []) print(zip(watcher.log[1], expect)) assert watcher.log[1] == expect class InheritableEventTestA(InheritableSQLObject): a = IntCol() class InheritableEventTestB(InheritableEventTestA): b = IntCol() class InheritableEventTestC(InheritableEventTestB): c = IntCol() def _query(instance): row = InheritableEventTestA.get(instance.id) assert isinstance(row, InheritableEventTestC) assert row.c == 3 def _signal(instance, kwargs, postfuncs): postfuncs.append(_query) def test_inheritance_row_created(): setupClass([InheritableEventTestA, InheritableEventTestB, InheritableEventTestC]) events.listen(_signal, InheritableEventTestA, events.RowCreatedSignal) InheritableEventTestC(a=1, b=2, c=3) SQLObject-3.1.0/sqlobject/tests/test_SQLMultipleJoin.py0000644000175000017500000000444112747416060022417 0ustar phdphd00000000000000import py.test from sqlobject import ForeignKey, IntCol, MultipleJoin, SQLMultipleJoin, \ SQLObject, StringCol from sqlobject.tests.dbtest import setupClass, supports class Race(SQLObject): name = StringCol() fightersAsList = MultipleJoin('RFighter', joinColumn="rf_id") fightersAsSResult = SQLMultipleJoin('RFighter', joinColumn="rf_id") class RFighter(SQLObject): name = StringCol() race = ForeignKey('Race', dbName="rf_id") power = IntCol() def createAllTables(): setupClass([Race, RFighter]) def test_1(): createAllTables() # create some races human = Race(name='human') saiyajin = Race(name='saiyajin') hibrid = Race(name='hibrid (human with sayajin)') namek = Race(name='namekuseijin') # create some fighters RFighter(name='Gokou (Kakaruto)', race=saiyajin, power=10) RFighter(name='Vegeta', race=saiyajin, power=9) RFighter(name='Krilim', race=human, power=3) RFighter(name='Yancha', race=human, power=2) RFighter(name='Jackie Chan', race=human, power=2) RFighter(name='Gohan', race=hibrid, power=8) RFighter(name='Goten', race=hibrid, power=7) trunks = RFighter(name='Trunks', race=hibrid, power=8) picollo = RFighter(name='Picollo', race=namek, power=6) RFighter(name='Neil', race=namek, power=5) # testing the SQLMultipleJoin stuff for i, j in zip(human.fightersAsList, human.fightersAsSResult): assert i is j # the 2 ways should give the same result assert namek.fightersAsSResult.count() == len(namek.fightersAsList) assert saiyajin.fightersAsSResult.max('power') == 10 assert trunks in hibrid.fightersAsSResult assert picollo not in hibrid.fightersAsSResult assert str(hibrid.fightersAsSResult.sum('power')) == '23' def test_multiple_join_transaction(): if not supports('transactions'): py.test.skip("Transactions aren't supported") createAllTables() trans = Race._connection.transaction() try: namek = Race(name='namekuseijin', connection=trans) RFighter(name='Gokou (Kakaruto)', race=namek, power=10, connection=trans) assert namek.fightersAsSResult.count() == 1 assert namek.fightersAsSResult[0]._connection == trans finally: trans.commit(True) Race._connection.autoCommit = True SQLObject-3.1.0/sqlobject/tests/test_SingleJoin.py0000644000175000017500000000202112747416060021455 0ustar phdphd00000000000000from sqlobject import ForeignKey, SQLObject, SingleJoin, StringCol from sqlobject.tests.dbtest import setupClass class PersonWithAlbum(SQLObject): name = StringCol() # albumNone returns the album or none albumNone = SingleJoin('PhotoAlbum', joinColumn='test_person_id') # albumInstance returns the album or an default album instance albumInstance = SingleJoin('PhotoAlbum', makeDefault=True, joinColumn='test_person_id') class PhotoAlbum(SQLObject): color = StringCol(default='red') person = ForeignKey('PersonWithAlbum', dbName='test_person_id') def test_1(): setupClass([PersonWithAlbum, PhotoAlbum]) person = PersonWithAlbum(name='Gokou (Kakarouto)') # We didn't create an album, this way it returns None assert not person.albumNone assert isinstance(person.albumInstance, PhotoAlbum) PhotoAlbum(person=person) assert person.albumNone assert isinstance(person.albumNone, PhotoAlbum) assert isinstance(person.albumInstance, PhotoAlbum) SQLObject-3.1.0/sqlobject/tests/test_select.py0000644000175000017500000001406012747416060020701 0ustar phdphd00000000000000import py.test from sqlobject import IntCol, LIKE, RLIKE, SQLObject, \ SQLObjectIntegrityError, SQLObjectNotFound, StringCol from sqlobject.sqlbuilder import func from .dbtest import raises, setupClass, supports, setSQLiteConnectionFactory class IterTest(SQLObject): name = StringCol(dbName='name_col', length=200) names = ('a', 'b', 'c') def setupIter(): setupClass(IterTest) for n in names: IterTest(name=n) def test_00_normal(): setupIter() count = 0 for test in IterTest.select(): count += 1 assert count == len(names) def test_00b_lazy(): setupIter() count = 0 for test in IterTest.select(lazyColumns=True): count += 1 assert count == len(names) def test_01_turn_to_list(): count = 0 for test in list(IterTest.select()): count += 1 assert count == len(names) def test_02_generator(): all = IterTest.select() count = 0 for i, test in enumerate(all): count += 1 assert count == len(names) def test_03_ranged_indexed(): all = IterTest.select() count = 0 for i in range(all.count()): all[i] # test it's there count += 1 assert count == len(names) def test_04_indexed_ended_by_exception(): if not supports('limitSelect'): py.test.skip("limitSelect isn't supported") all = IterTest.select() count = 0 try: while 1: all[count] count = count + 1 # Stop the test if it's gone on too long if count > len(names): break except IndexError: pass assert count == len(names) def test_05_select_limit(): setupIter() assert len(list(IterTest.select(limit=2))) == 2 raises(AssertionError, IterTest.select(limit=2).count) def test_06_contains(): setupIter() assert len(list(IterTest.select(IterTest.q.name.startswith('a')))) == 1 assert len(list(IterTest.select(IterTest.q.name.contains('a')))) == 1 assert len(list(IterTest.select( IterTest.q.name.contains(func.lower('A'))))) == 1 assert len(list(IterTest.select(IterTest.q.name.contains("a'b")))) == 0 assert len(list(IterTest.select(IterTest.q.name.endswith('a')))) == 1 def test_07_contains_special(): setupClass(IterTest) a = IterTest(name='\\test') b = IterTest(name='100%') c = IterTest(name='test_') assert list(IterTest.select(IterTest.q.name.startswith('\\'))) == [a] assert list(IterTest.select(IterTest.q.name.contains('%'))) == [b] assert list(IterTest.select(IterTest.q.name.endswith('_'))) == [c] def test_select_getOne(): setupClass(IterTest) a = IterTest(name='a') b = IterTest(name='b') assert IterTest.selectBy(name='a').getOne() == a assert IterTest.select(IterTest.q.name == 'b').getOne() == b assert IterTest.selectBy(name='c').getOne(None) is None raises(SQLObjectNotFound, 'IterTest.selectBy(name="c").getOne()') IterTest(name='b') raises(SQLObjectIntegrityError, 'IterTest.selectBy(name="b").getOne()') raises(SQLObjectIntegrityError, 'IterTest.selectBy(name="b").getOne(None)') def test_selectBy(): setupClass(IterTest) IterTest(name='a') IterTest(name='b') assert IterTest.selectBy().count() == 2 def test_selectBy_kwargs(): setupClass(IterTest) raises(TypeError, IterTest, nonexistant='b') class UniqTest(SQLObject): name = StringCol(dbName='name_col', unique=True, length=100) def test_by_uniq(): setupClass(UniqTest) a = UniqTest(name='a') b = UniqTest(name='b') assert UniqTest.byName('a') is a assert UniqTest.byName('b') is b class Counter2(SQLObject): n1 = IntCol(notNull=True) n2 = IntCol(notNull=True) class TestSelect: def setup_method(self, meth): setupClass(Counter2) for i in range(10): for j in range(10): Counter2(n1=i, n2=j) def counterEqual(self, counters, value): assert [(c.n1, c.n2) for c in counters] == value def accumulateEqual(self, func, counters, value): assert func([c.n1 for c in counters]) == value def test_1(self): self.accumulateEqual(sum, Counter2.select(orderBy='n1'), sum(range(10)) * 10) def test_2(self): self.accumulateEqual(len, Counter2.select('all'), 100) def test_select_LIKE(): setupClass(IterTest) IterTest(name='sqlobject') IterTest(name='sqlbuilder') assert IterTest.select(LIKE(IterTest.q.name, "sql%")).count() == 2 assert IterTest.select(LIKE(IterTest.q.name, "sqlb%")).count() == 1 assert IterTest.select(LIKE(IterTest.q.name, "sqlb%")).count() == 1 assert IterTest.select(LIKE(IterTest.q.name, "sqlx%")).count() == 0 def test_select_RLIKE(): setupClass(IterTest) if IterTest._connection.dbName == "sqlite": if not IterTest._connection.using_sqlite2: py.test.skip("These tests require SQLite v2+") # Implement regexp() function for SQLite; only works with PySQLite2 import re def regexp(regexp, test): return bool(re.search(regexp, test)) def SQLiteConnectionFactory(sqlite): class MyConnection(sqlite.Connection): def __init__(self, *args, **kwargs): super(MyConnection, self).__init__(*args, **kwargs) self.create_function("regexp", 2, regexp) return MyConnection setSQLiteConnectionFactory(IterTest, SQLiteConnectionFactory) IterTest(name='sqlobject') IterTest(name='sqlbuilder') assert IterTest.select(RLIKE(IterTest.q.name, "^sql.*$")).count() == 2 assert IterTest.select(RLIKE(IterTest.q.name, "^sqlb.*$")).count() == 1 assert IterTest.select(RLIKE(IterTest.q.name, "^sqlb.*$")).count() == 1 assert IterTest.select(RLIKE(IterTest.q.name, "^sqlx.*$")).count() == 0 def test_select_sqlbuilder(): setupClass(IterTest) IterTest(name='sqlobject') IterTest.select(IterTest.q.name == u'sqlobject') def test_select_perConnection(): setupClass(IterTest) IterTest(name='a') assert not IterTest.select().getOne().sqlmeta._perConnection SQLObject-3.1.0/sqlobject/tests/test_constraints.py0000644000175000017500000000237412747416060021776 0ustar phdphd00000000000000from sqlobject.compat import PY2 from sqlobject.constraints import BadValue, InList, MaxLength, \ isFloat, isInt, isString, notNull from sqlobject.tests.dbtest import Dummy, raises if not PY2: # alias for python 3 compatability long = int def test_constraints(): obj = 'Test object' col = Dummy(name='col') isString(obj, col, 'blah') raises(BadValue, isString, obj, col, 1) if PY2: # @@: Should this really be an error? raises(BadValue, isString, obj, col, u'test!') else: raises(BadValue, isString, obj, col, b'test!') # isString(obj, col, u'test!') raises(BadValue, notNull, obj, col, None) raises(BadValue, isInt, obj, col, 1.1) isInt(obj, col, 1) isInt(obj, col, long(1)) isFloat(obj, col, 1) isFloat(obj, col, long(1)) isFloat(obj, col, 1.2) raises(BadValue, isFloat, obj, col, '1.0') # @@: Should test isBool, but I don't think isBool is right lst = InList(('a', 'b', 'c')) lst(obj, col, 'a') raises(BadValue, lst, obj, col, ('a', 'b', 'c')) raises(BadValue, lst, obj, col, 'A') maxlen = MaxLength(2) raises(BadValue, maxlen, obj, col, '123') maxlen(obj, col, '12') maxlen(obj, col, (1,)) raises(BadValue, maxlen, obj, col, 1) SQLObject-3.1.0/sqlobject/tests/test_groupBy.py0000644000175000017500000000243112747416060021050 0ustar phdphd00000000000000from sqlobject import IntCol, SQLObject, StringCol from sqlobject.sqlbuilder import Select, func from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # groupBy ######################################## class GroupbyTest(SQLObject): name = StringCol() value = IntCol() def test_groupBy(): setupClass(GroupbyTest) GroupbyTest(name='a', value=1) GroupbyTest(name='a', value=2) GroupbyTest(name='b', value=1) connection = getConnection() select = Select( [GroupbyTest.q.name, func.COUNT(GroupbyTest.q.value)], groupBy=GroupbyTest.q.name, orderBy=GroupbyTest.q.name) sql = connection.sqlrepr(select) rows = connection.queryAll(sql) assert list(rows) == [('a', 2), ('b', 1)] def test_groupBy_list(): setupClass(GroupbyTest) GroupbyTest(name='a', value=1) GroupbyTest(name='a', value=2) GroupbyTest(name='b', value=1) connection = getConnection() select = Select( [GroupbyTest.q.name, GroupbyTest.q.value], groupBy=[GroupbyTest.q.name, GroupbyTest.q.value], orderBy=[GroupbyTest.q.name, GroupbyTest.q.value]) sql = connection.sqlrepr(select) rows = connection.queryAll(sql) assert list(rows) == [('a', 1), ('a', 2), ('b', 1)] SQLObject-3.1.0/sqlobject/tests/test_datetime.py0000644000175000017500000001046212753526731021224 0ustar phdphd00000000000000from datetime import datetime, date, time import py.test from sqlobject import SQLObject from sqlobject import col from sqlobject.col import DATETIME_IMPLEMENTATION, DateCol, DateTimeCol, \ MXDATETIME_IMPLEMENTATION, TimeCol, mxdatetime_available, use_microseconds from sqlobject.tests.dbtest import getConnection, setupClass ######################################## # Date/time columns ######################################## col.default_datetime_implementation = DATETIME_IMPLEMENTATION class DateTime1(SQLObject): col1 = DateTimeCol() col2 = DateCol() col3 = TimeCol() def test_dateTime(): setupClass(DateTime1) _now = datetime.now() dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time()) assert isinstance(dt1.col1, datetime) assert dt1.col1.year == _now.year assert dt1.col1.month == _now.month assert dt1.col1.day == _now.day assert dt1.col1.hour == _now.hour assert dt1.col1.minute == _now.minute assert dt1.col1.second == _now.second assert isinstance(dt1.col2, date) assert not isinstance(dt1.col2, datetime) assert dt1.col2.year == _now.year assert dt1.col2.month == _now.month assert dt1.col2.day == _now.day assert isinstance(dt1.col3, time) assert dt1.col3.hour == _now.hour assert dt1.col3.minute == _now.minute assert dt1.col3.second == _now.second def test_microseconds(): connection = getConnection() if hasattr(connection, 'can_use_microseconds') and \ not connection.can_use_microseconds(): py.test.skip( "The database doesn't support microseconds; " "microseconds are supported by MariaDB since version 5.3.0, " "by MySQL since version 5.6.4, " "by MSSQL since MS SQL Server 2008.") setupClass(DateTime1) _now = datetime.now() dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time()) assert dt1.col1.microsecond == _now.microsecond assert dt1.col3.microsecond == _now.microsecond use_microseconds(False) setupClass(DateTime1) _now = datetime.now() dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time()) assert dt1.col1.microsecond == 0 assert dt1.col3.microsecond == 0 use_microseconds(True) setupClass(DateTime1) _now = datetime.now() dt1 = DateTime1(col1=_now, col2=_now, col3=_now.time()) assert dt1.col1.microsecond == _now.microsecond assert dt1.col3.microsecond == _now.microsecond if mxdatetime_available: col.default_datetime_implementation = MXDATETIME_IMPLEMENTATION from mx.DateTime import now, Time dateFormat = None # use default try: connection = getConnection() except AttributeError: # The module was imported during documentation building pass else: if connection.dbName == "sqlite": if connection.using_sqlite2: # mxDateTime sends and PySQLite2 returns # full date/time for dates dateFormat = "%Y-%m-%d %H:%M:%S.%f" class DateTime2(SQLObject): col1 = DateTimeCol() col2 = DateCol(dateFormat=dateFormat) col3 = TimeCol() def test_mxDateTime(): setupClass(DateTime2) _now = now() dt2 = DateTime2(col1=_now, col2=_now, col3=Time(_now.hour, _now.minute, _now.second)) assert isinstance(dt2.col1, col.DateTimeType) assert dt2.col1.year == _now.year assert dt2.col1.month == _now.month assert dt2.col1.day == _now.day assert dt2.col1.hour == _now.hour assert dt2.col1.minute == _now.minute assert dt2.col1.second == int(_now.second) assert isinstance(dt2.col2, col.DateTimeType) assert dt2.col2.year == _now.year assert dt2.col2.month == _now.month assert dt2.col2.day == _now.day if getConnection().dbName == "sqlite": assert dt2.col2.hour == _now.hour assert dt2.col2.minute == _now.minute assert dt2.col2.second == int(_now.second) else: assert dt2.col2.hour == 0 assert dt2.col2.minute == 0 assert dt2.col2.second == 0 assert isinstance(dt2.col3, (col.DateTimeType, col.TimeType)) assert dt2.col3.hour == _now.hour assert dt2.col3.minute == _now.minute assert dt2.col3.second == int(_now.second) SQLObject-3.1.0/sqlobject/tests/test_blob.py0000644000175000017500000000134012747416060020335 0ustar phdphd00000000000000import py.test from sqlobject import BLOBCol, SQLObject from sqlobject.compat import PY2 from sqlobject.tests.dbtest import setupClass, supports ######################################## # BLOB columns ######################################## class ImageData(SQLObject): image = BLOBCol(default=b'emptydata', length=65535) def test_BLOBCol(): if not supports('blobData'): py.test.skip("blobData isn't supported") setupClass(ImageData) if PY2: data = ''.join([chr(x) for x in range(256)]) else: data = bytes(range(256)) prof = ImageData() prof.image = data iid = prof.id ImageData._connection.cache.clear() prof2 = ImageData.get(iid) assert prof2.image == data SQLObject-3.1.0/sqlobject/tests/test_expire.py0000644000175000017500000000136212747416060020717 0ustar phdphd00000000000000from sqlobject import SQLObject, StringCol from sqlobject.tests.dbtest import setupClass ######################################## # Expiring, syncing ######################################## class SyncTest(SQLObject): name = StringCol(length=50, alternateID=True, dbName='name_col') def test_expire(): setupClass(SyncTest) SyncTest(name='bob') SyncTest(name='tim') conn = SyncTest._connection b = SyncTest.byName('bob') conn.query("UPDATE sync_test SET name_col = 'robert' WHERE id = %i" % b.id) assert b.name == 'bob' b.expire() assert b.name == 'robert' conn.query("UPDATE sync_test SET name_col = 'bobby' WHERE id = %i" % b.id) b.sync() assert b.name == 'bobby' SQLObject-3.1.0/sqlobject/tests/test_decimal.py0000644000175000017500000000445712753526731021035 0ustar phdphd00000000000000from decimal import Decimal import py.test from sqlobject import DecimalCol, DecimalStringCol, SQLObject, UnicodeCol from sqlobject.tests.dbtest import setupClass, supports ######################################## # Decimal columns ######################################## try: support_decimal_column = supports('decimalColumn') except NameError: # The module was imported during documentation building support_decimal_column = True if not support_decimal_column: pytestmark = py.test.mark.skip('') class DecimalTable(SQLObject): name = UnicodeCol(length=255) col1 = DecimalCol(size=6, precision=4) col2 = DecimalStringCol(size=6, precision=4) col3 = DecimalStringCol(size=6, precision=4, quantize=True) def test_1_decimal(): setupClass(DecimalTable) d = DecimalTable(name='test', col1=21.12, col2='10.01', col3='10.01') # psycopg2 returns float as Decimal if isinstance(d.col1, Decimal): assert d.col1 == Decimal("21.12") else: assert d.col1 == 21.12 assert d.col2 == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col2'].to_python( '10.01', d._SO_validatorState) == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col2'].from_python( '10.01', d._SO_validatorState) == "10.01" assert d.col3 == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col3'].to_python( '10.01', d._SO_validatorState) == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col3'].from_python( '10.01', d._SO_validatorState) == "10.0100" def test_2_decimal(): setupClass(DecimalTable) d = DecimalTable(name='test', col1=Decimal("21.12"), col2=Decimal('10.01'), col3=Decimal('10.01')) assert d.col1 == Decimal("21.12") assert d.col2 == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col2'].to_python( Decimal('10.01'), d._SO_validatorState) == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col2'].from_python( Decimal('10.01'), d._SO_validatorState) == "10.01" assert d.col3 == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col3'].to_python( Decimal('10.01'), d._SO_validatorState) == Decimal("10.01") assert DecimalTable.sqlmeta.columns['col3'].from_python( Decimal('10.01'), d._SO_validatorState) == "10.0100" SQLObject-3.1.0/sqlobject/.gitignore0000644000175000017500000000003112751432445016630 0ustar phdphd00000000000000/.coverage /coverage.xml SQLObject-3.1.0/sqlobject/sresults.py0000644000175000017500000003537512472652005017115 0ustar phdphd00000000000000from . import dbconnection from . import sqlbuilder from .compat import string_type __all__ = ['SelectResults'] class SelectResults(object): IterationClass = dbconnection.Iteration def __init__(self, sourceClass, clause, clauseTables=None, **ops): self.sourceClass = sourceClass if clause is None or isinstance(clause, str) and clause == 'all': clause = sqlbuilder.SQLTrueClause if not isinstance(clause, sqlbuilder.SQLExpression): clause = sqlbuilder.SQLConstant(clause) self.clause = clause self.ops = ops if ops.get('orderBy', sqlbuilder.NoDefault) is sqlbuilder.NoDefault: ops['orderBy'] = sourceClass.sqlmeta.defaultOrder orderBy = ops['orderBy'] if isinstance(orderBy, (tuple, list)): orderBy = list(map(self._mungeOrderBy, orderBy)) else: orderBy = self._mungeOrderBy(orderBy) ops['dbOrderBy'] = orderBy if 'connection' in ops and ops['connection'] is None: del ops['connection'] if ops.get('limit', None): assert not ops.get('start', None) and not ops.get('end', None), \ "'limit' cannot be used with 'start' or 'end'" ops["start"] = 0 ops["end"] = ops.pop("limit") tablesSet = sqlbuilder.tablesUsedSet(self.clause, self._getConnection().dbName) if clauseTables: for table in clauseTables: tablesSet.add(table) self.clauseTables = clauseTables # Explicitly post-adding-in sqlmeta.table, # sqlbuilder.Select will handle sqlrepr'ing and dupes. self.tables = list(tablesSet) + [sourceClass.sqlmeta.table] def queryForSelect(self): columns = [self.sourceClass.q.id] + \ [getattr(self.sourceClass.q, x.name) for x in self.sourceClass.sqlmeta.columnList] query = sqlbuilder.Select(columns, where=self.clause, join=self.ops.get( 'join', sqlbuilder.NoDefault), distinct=self.ops.get('distinct', False), lazyColumns=self.ops.get( 'lazyColumns', False), start=self.ops.get('start', 0), end=self.ops.get('end', None), orderBy=self.ops.get( 'dbOrderBy', sqlbuilder.NoDefault), reversed=self.ops.get('reversed', False), staticTables=self.tables, forUpdate=self.ops.get('forUpdate', False)) return query def __repr__(self): return "<%s at %x>" % (self.__class__.__name__, id(self)) def _getConnection(self): return self.ops.get('connection') or self.sourceClass._connection def __str__(self): conn = self._getConnection() return conn.queryForSelect(self) def _mungeOrderBy(self, orderBy): if isinstance(orderBy, string_type) and orderBy.startswith('-'): orderBy = orderBy[1:] desc = True else: desc = False if isinstance(orderBy, string_type): if orderBy in self.sourceClass.sqlmeta.columns: val = getattr(self.sourceClass.q, self.sourceClass.sqlmeta.columns[orderBy].name) if desc: return sqlbuilder.DESC(val) else: return val else: orderBy = sqlbuilder.SQLConstant(orderBy) if desc: return sqlbuilder.DESC(orderBy) else: return orderBy else: return orderBy def clone(self, **newOps): ops = self.ops.copy() ops.update(newOps) return self.__class__(self.sourceClass, self.clause, self.clauseTables, **ops) def orderBy(self, orderBy): return self.clone(orderBy=orderBy) def connection(self, conn): return self.clone(connection=conn) def limit(self, limit): return self[:limit] def lazyColumns(self, value): return self.clone(lazyColumns=value) def reversed(self): return self.clone(reversed=not self.ops.get('reversed', False)) def distinct(self): return self.clone(distinct=True) def newClause(self, new_clause): return self.__class__(self.sourceClass, new_clause, self.clauseTables, **self.ops) def filter(self, filter_clause): if filter_clause is None: # None doesn't filter anything, it's just a no-op: return self clause = self.clause if isinstance(clause, string_type): clause = sqlbuilder.SQLConstant('(%s)' % clause) return self.newClause(sqlbuilder.AND(clause, filter_clause)) def __getitem__(self, value): if isinstance(value, slice): assert not value.step, "Slices do not support steps" if not value.start and not value.stop: # No need to copy, I'm immutable return self # Negative indexes aren't handled (and everything we # don't handle ourselves we just create a list to # handle) if (value.start and value.start < 0) \ or (value.stop and value.stop < 0): if value.start: if value.stop: return list(self)[value.start:value.stop] return list(self)[value.start:] return list(self)[:value.stop] if value.start: assert value.start >= 0 start = self.ops.get('start', 0) + value.start if value.stop is not None: assert value.stop >= 0 if value.stop < value.start: # an empty result: end = start else: end = value.stop + self.ops.get('start', 0) if self.ops.get('end', None) is not None and \ self.ops['end'] < end: # truncated by previous slice: end = self.ops['end'] else: end = self.ops.get('end', None) else: start = self.ops.get('start', 0) end = value.stop + start if self.ops.get('end', None) is not None \ and self.ops['end'] < end: end = self.ops['end'] return self.clone(start=start, end=end) else: if value < 0: return list(iter(self))[value] else: start = self.ops.get('start', 0) + value return list(self.clone(start=start, end=start + 1))[0] def __iter__(self): # @@: This could be optimized, using a simpler algorithm # since we don't have to worry about garbage collection, # etc., like we do with .lazyIter() return iter(list(self.lazyIter())) def lazyIter(self): """ Returns an iterator that will lazily pull rows out of the database and return SQLObject instances """ conn = self._getConnection() return conn.iterSelect(self) def accumulate(self, *expressions): """ Use accumulate expression(s) to select result using another SQL select through current connection. Return the accumulate result """ conn = self._getConnection() exprs = [] for expr in expressions: if not isinstance(expr, sqlbuilder.SQLExpression): expr = sqlbuilder.SQLConstant(expr) exprs.append(expr) return conn.accumulateSelect(self, *exprs) def count(self): """ Counting elements of current select results """ assert not self.ops.get('start') and not self.ops.get('end'), \ "start/end/limit have no meaning with 'count'" assert not (self.ops.get('distinct') and (self.ops.get('start') or self.ops.get('end'))), \ "distinct-counting of sliced objects is not supported" if self.ops.get('distinct'): # Column must be specified, so we are using unique ID column. # COUNT(DISTINCT column) is supported by MySQL and PostgreSQL, # but not by SQLite. Perhaps more portable would be subquery: # SELECT COUNT(*) FROM (SELECT DISTINCT id FROM table) count = self.accumulate( 'COUNT(DISTINCT %s)' % self._getConnection().sqlrepr( self.sourceClass.q.id)) else: count = self.accumulate('COUNT(*)') if self.ops.get('start'): count -= self.ops['start'] if self.ops.get('end'): count = min(self.ops['end'] - self.ops.get('start', 0), count) return count def accumulateMany(self, *attributes): """ Making the expressions for count/sum/min/max/avg of a given select result attributes. `attributes` must be a list/tuple of pairs (func_name, attribute); `attribute` can be a column name (like 'a_column') or a dot-q attribute (like Table.q.aColumn) """ expressions = [] conn = self._getConnection() if self.ops.get('distinct'): distinct = 'DISTINCT ' else: distinct = '' for func_name, attribute in attributes: if not isinstance(attribute, str): attribute = conn.sqlrepr(attribute) expression = '%s(%s%s)' % (func_name, distinct, attribute) expressions.append(expression) return self.accumulate(*expressions) def accumulateOne(self, func_name, attribute): """ Making the sum/min/max/avg of a given select result attribute. `attribute` can be a column name (like 'a_column') or a dot-q attribute (like Table.q.aColumn) """ return self.accumulateMany((func_name, attribute)) def sum(self, attribute): return self.accumulateOne("SUM", attribute) def min(self, attribute): return self.accumulateOne("MIN", attribute) def avg(self, attribute): return self.accumulateOne("AVG", attribute) def max(self, attribute): return self.accumulateOne("MAX", attribute) def getOne(self, default=sqlbuilder.NoDefault): """ If a query is expected to only return a single value, using ``.getOne()`` will return just that value. If not results are found, ``SQLObjectNotFound`` will be raised, unless you pass in a default value (like ``.getOne(None)``). If more than one result is returned, ``SQLObjectIntegrityError`` will be raised. """ from . import main results = list(self) if not results: if default is sqlbuilder.NoDefault: raise main.SQLObjectNotFound( "No results matched the query for %s" % self.sourceClass.__name__) return default if len(results) > 1: raise main.SQLObjectIntegrityError( "More than one result returned from query: %s" % results) return results[0] def throughTo(self): class _throughTo_getter(object): def __init__(self, inst): self.sresult = inst def __getattr__(self, attr): return self.sresult._throughTo(attr) return _throughTo_getter(self) throughTo = property(throughTo) def _throughTo(self, attr): otherClass = None orderBy = sqlbuilder.NoDefault ref = self.sourceClass.sqlmeta.columns.get( attr.endswith('ID') and attr or attr + 'ID', None) if ref and ref.foreignKey: otherClass, clause = self._throughToFK(ref) else: join = [x for x in self.sourceClass.sqlmeta.joins if x.joinMethodName == attr] if join: join = join[0] orderBy = join.orderBy if hasattr(join, 'otherColumn'): otherClass, clause = self._throughToRelatedJoin(join) else: otherClass, clause = self._throughToMultipleJoin(join) if not otherClass: raise AttributeError( "throughTo argument (got %s) should be " "name of foreignKey or SQL*Join in %s" % (attr, self.sourceClass)) return otherClass.select(clause, orderBy=orderBy, connection=self._getConnection()) def _throughToFK(self, col): otherClass = getattr(self.sourceClass, "_SO_class_" + col.foreignKey) colName = col.name query = self.queryForSelect().newItems([ sqlbuilder.ColumnAS(getattr(self.sourceClass.q, colName), colName) ]).orderBy(None).distinct() query = sqlbuilder.Alias(query, "%s_%s" % (self.sourceClass.__name__, col.name)) return otherClass, otherClass.q.id == getattr(query.q, colName) def _throughToMultipleJoin(self, join): otherClass = join.otherClass colName = join.soClass.sqlmeta.style.\ dbColumnToPythonAttr(join.joinColumn) query = self.queryForSelect().newItems( [sqlbuilder.ColumnAS(self.sourceClass.q.id, 'id')]).\ orderBy(None).distinct() query = sqlbuilder.Alias(query, "%s_%s" % (self.sourceClass.__name__, join.joinMethodName)) joinColumn = getattr(otherClass.q, colName) return otherClass, joinColumn == query.q.id def _throughToRelatedJoin(self, join): otherClass = join.otherClass intTable = sqlbuilder.Table(join.intermediateTable) colName = join.joinColumn query = self.queryForSelect().newItems( [sqlbuilder.ColumnAS(self.sourceClass.q.id, 'id')]).\ orderBy(None).distinct() query = sqlbuilder.Alias(query, "%s_%s" % (self.sourceClass.__name__, join.joinMethodName)) clause = sqlbuilder.AND( otherClass.q.id == getattr(intTable, join.otherColumn), getattr(intTable, colName) == query.q.id) return otherClass, clause SQLObject-3.1.0/sqlobject/rdbhost/0000755000175000017500000000000012754657361016324 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/rdbhost/__init__.py0000644000175000017500000000030412464733165020425 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import rdbhostconnection return rdbhostconnection.RdbhostConnection registerConnection(['rdbhost'], builder) SQLObject-3.1.0/sqlobject/rdbhost/rdbhostconnection.py0000644000175000017500000000477512461505074022424 0ustar phdphd00000000000000""" This module written by David Keeney, 2009, 2010 Released under the LGPL for use with the SQLObject ORM library. """ from sqlobject.dbconnection import DBAPI from sqlobject.postgres.pgconnection import PostgresConnection class RdbhostConnection(PostgresConnection): supportTransactions = False dbName = 'rdbhost' schemes = [dbName] def __init__(self, dsn=None, host=None, port=None, db=None, user=None, password=None, unicodeCols=False, driver='rdbhost', **kw): drivers = driver for driver in drivers.split(','): driver = driver.strip() if not driver: continue try: if driver == 'rdbhost': from rdbhdb import rdbhdb as rdb # monkey patch % escaping into Cursor._execute old_execute = getattr(rdb.Cursor, '_execute') setattr(rdb.Cursor, '_old_execute', old_execute) def _execute(self, query, *args): assert not any([a for a in args]) query = query.replace('%', '%%') self._old_execute(query, (), (), ()) setattr(rdb.Cursor, '_execute', _execute) self.module = rdb else: raise ValueError('Unknown Rdbhost driver %s' % driver) except ImportError: pass else: break else: raise ImportError('Cannot find the Rdbhost driver') self.user = user self.host = host self.port = port self.db = db self.password = password self.dsn_dict = dsn_dict = {} self.use_dsn = dsn is not None if host: dsn_dict["host"] = host if user: dsn_dict["role"] = user if password: dsn_dict["authcode"] = password if dsn is None: dsn = [] if db: dsn.append('dbname=%s' % db) if user: dsn.append('user=%s' % user) if password: dsn.append('password=%s' % password) if host: dsn.append('host=%s' % host) if port: dsn.append('port=%d' % port) dsn = ' '.join(dsn) self.dsn = dsn self.unicodeCols = unicodeCols self.schema = kw.pop('schema', None) self.dbEncoding = 'utf-8' DBAPI.__init__(self, **kw) SQLObject-3.1.0/sqlobject/versioning/0000755000175000017500000000000012754657361017042 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/versioning/__init__.py0000644000175000017500000000754112470177652021155 0ustar phdphd00000000000000from datetime import datetime from sqlobject import col, events, SQLObject, AND class Version(SQLObject): def restore(self): values = self.sqlmeta.asDict() del values['id'] del values['masterID'] del values['dateArchived'] for _col in self.extraCols: del values[_col] self.masterClass.get(self.masterID).set(**values) def nextVersion(self): version = self.select( AND(self.q.masterID == self.masterID, self.q.id > self.id), orderBy=self.q.id) if version.count(): return version[0] else: return self.master def getChangedFields(self): next = self.nextVersion() columns = self.masterClass.sqlmeta.columns fields = [] for column in columns: if column not in ["dateArchived", "id", "masterID"]: if getattr(self, column) != getattr(next, column): fields.append(column.title()) return fields @classmethod def select(cls, clause=None, *args, **kw): if not getattr(cls, '_connection', None): cls._connection = cls.masterClass._connection return super(Version, cls).select(clause, *args, **kw) def __getattr__(self, attr): if attr in self.__dict__: return self.__dict__[attr] else: return getattr(self.master, attr) def getColumns(columns, cls): for column, defi in cls.sqlmeta.columnDefinitions.items(): if column.endswith("ID") and isinstance(defi, col.ForeignKey): column = column[:-2] # remove incompatible constraints kwds = dict(defi._kw) for kw in ["alternateID", "unique"]: if kw in kwds: del kwds[kw] columns[column] = defi.__class__(**kwds) # ascend heirarchy if cls.sqlmeta.parentClass: getColumns(columns, cls.sqlmeta.parentClass) class Versioning(object): def __init__(self, extraCols=None): if extraCols: self.extraCols = extraCols else: self.extraCols = {} pass def __addtoclass__(self, soClass, name): self.name = name self.soClass = soClass attrs = {'dateArchived': col.DateTimeCol(default=datetime.now), 'master': col.ForeignKey(self.soClass.__name__), 'masterClass': self.soClass, 'extraCols': self.extraCols } getColumns(attrs, self.soClass) attrs.update(self.extraCols) self.versionClass = type(self.soClass.__name__ + 'Versions', (Version,), attrs) if '_connection' in self.soClass.__dict__: self.versionClass._connection = \ self.soClass.__dict__['_connection'] events.listen(self.createTable, soClass, events.CreateTableSignal) events.listen(self.rowUpdate, soClass, events.RowUpdateSignal) def createVersionTable(self, cls, conn): self.versionClass.createTable(ifNotExists=True, connection=conn) def createTable(self, soClass, connection, extra_sql, post_funcs): assert soClass is self.soClass post_funcs.append(self.createVersionTable) def rowUpdate(self, instance, kwargs): if instance.childName and instance.childName != self.soClass.__name__: return # if you want your child class versioned, version it values = instance.sqlmeta.asDict() del values['id'] values['masterID'] = instance.id self.versionClass(connection=instance._connection, **values) def __get__(self, obj, type=None): if obj is None: return self return self.versionClass.select( self.versionClass.q.masterID == obj.id, connection=obj._connection) SQLObject-3.1.0/sqlobject/versioning/test/0000755000175000017500000000000012754657361020021 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/versioning/test/__init__.py0000644000175000017500000000000010545027231022077 0ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/versioning/test/test_version.py0000644000175000017500000001147012747416060023111 0ustar phdphd00000000000000from sqlobject import ForeignKey, IntCol, SQLObject, StringCol from sqlobject.inheritance import InheritableSQLObject from sqlobject.versioning import Versioning from sqlobject.tests.dbtest import setupClass class MyClass(SQLObject): name = StringCol() versions = Versioning() class Base(InheritableSQLObject): name = StringCol() value = IntCol(default=0) versions = Versioning() class Child(Base): toy = StringCol() class Government(InheritableSQLObject): name = StringCol() class Monarchy(Government): monarch = StringCol() versions = Versioning() class VChild(Base): weapon = StringCol() versions = Versioning() class HasForeign(SQLObject): foreign = ForeignKey("Base") versions = Versioning() def _set_extra(): return "read all about it" class Extra(SQLObject): name = StringCol() versions = Versioning( extraCols={'extra': StringCol(default=_set_extra())}) class HasAltId(SQLObject): name = StringCol() altid = IntCol(alternateID=True) versions = Versioning() def setup(): classes = [MyClass, Base, Child, Government, Monarchy, VChild, Extra, HasAltId] if hasattr(HasForeign, "_connection"): classes.insert(0, HasForeign) else: classes.append(HasForeign) for cls in classes: if hasattr(cls, 'versions') and getattr(cls, "_connection", None) and \ cls._connection.tableExists(cls.sqlmeta.table): setupClass(cls.versions.versionClass) setupClass(cls) if hasattr(cls, 'versions'): setupClass(cls.versions.versionClass) for version in cls.versions.versionClass.select(): version.destroySelf() def test_versioning(): # the simple case setup() mc = MyClass(name='fleem') mc.set(name='morx') assert len(list(mc.versions)) == 1 assert mc.versions[0].name == "fleem" assert len(list(MyClass.select())) == 1 def test_inheritable_versioning(): setup() # base versioned, child unversioned base = Base(name='fleem') base.set(name='morx') assert len(list(base.versions)) == 1 assert base.versions[0].name == "fleem" assert len(list(Base.select())) == 1 child = Child(name='child', toy='nintendo') child.set(name='teenager', toy='guitar') assert len(list(child.versions)) == 0 # child versioned, base unversioned government = Government(name='canada') assert not hasattr(government, 'versions') monarchy = Monarchy(name='UK', monarch='king george iv') assert len(list(monarchy.versions)) == 0 monarchy.set(name='queen elisabeth ii') assert len(list(monarchy.versions)) == 1 assert monarchy.versions[0].name == "UK" assert len(list(Monarchy.select())) == 1 # both parent and child versioned num_base_versions = len(list(base.versions)) vchild = VChild(name='kid', weapon='slingshot') vchild.set(name='toon', weapon='dynamite') assert len(list(base.versions)) == num_base_versions assert len(list(vchild.versions)) == 1 # test setting using setattr directly rather than .set vchild.name = "newname" assert len(list(vchild.versions)) == 2 def test_restore(): setup() base = Base(name='fleem') base.set(name='morx') assert base.name == "morx" base.versions[0].restore() assert base.name == "fleem" monarchy = Monarchy(name='USA', monarch='Emperor Norton I') monarchy.set(name='morx') assert monarchy.name == "morx" monarchy.versions[0].restore() assert monarchy.name == "USA" assert monarchy.monarch == "Emperor Norton I" extra = Extra(name='fleem') extra.set(name='morx') assert extra.name == "morx" extra.versions[0].restore() assert extra.name == "fleem" def test_next(): setup() base = Base(name='first', value=1) base.set(name='second') base.set(name='third', value=2) version = base.versions[0] assert version.nextVersion() == base.versions[1] assert version.nextVersion().nextVersion() == base def test_get_changed(): setup() base = Base(name='first', value=1) base.set(name='second') base.set(name='third', value=2) assert base.versions[0].getChangedFields() == ['Name'] assert sorted(base.versions[1].getChangedFields()) == ['Name', 'Value'] def test_foreign_keys(): setup() base1 = Base(name='first', value=1) base2 = Base(name='first', value=1) has_foreign = HasForeign(foreign=base1) has_foreign.foreign = base2 assert has_foreign.versions[0].foreign == base1 def test_extra(): setup() extra = Extra(name='title') extra.name = 'new' assert extra.versions[0].extra == 'read all about it' assert sorted(extra.versions[0].getChangedFields()) == ['Name'] def test_altid(): setup() extra = HasAltId(name="fleem", altid=5) extra.name = "morx" SQLObject-3.1.0/sqlobject/util/0000755000175000017500000000000012754657361015634 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/util/threadinglocal.py0000644000175000017500000000023011537673704021156 0ustar phdphd00000000000000try: from threading import local except ImportError: # No threads, so "thread local" means process-global class local(object): pass SQLObject-3.1.0/sqlobject/util/__init__.py0000644000175000017500000000000210223346763017723 0ustar phdphd00000000000000# SQLObject-3.1.0/sqlobject/util/csvimport.py0000644000175000017500000002572612470215762020236 0ustar phdphd00000000000000""" Import from a CSV file or directory of files. CSV files should have a header line that lists columns. Headers can also be appended with ``:type`` to indicate the type of the field. ``escaped`` is the default, though it can be overridden by the importer. Supported types: ``:python``: A python expression, run through ``eval()``. This can be a security risk, pass in ``allow_python=False`` if you don't want to allow it. ``:int``: Integer ``:float``: Float ``:str``: String ``:escaped``: A string with backslash escapes (note that you don't put quotation marks around the value) ``:base64``: A base64-encoded string ``:date``: ISO date, like YYYY-MM-DD; this can also be ``NOW+days`` or ``NOW-days`` ``:datetime``: ISO date/time like YYYY-MM-DDTHH:MM:SS (either T or a space can be used to separate the time, and seconds are optional). This can also be ``NOW+seconds`` or ``NOW-seconds`` ``:bool``: Converts true/false/yes/no/on/off/1/0 to boolean value ``:ref``: This will be resolved to the ID of the object named in this column (None if the column is empty). @@: Since there's no ordering, there's no way to promise the object already exists. You can also get back references to the objects if you have a special ``[name]`` column. Any column named ``[comment]`` or with no name will be ignored. In any column you can put ``[default]`` to exclude the value and use whatever default the class wants. ``[null]`` will use NULL. Lines that begin with ``[comment]`` are ignored. """ import csv from datetime import datetime, date, timedelta import os import time import types __all__ = ['load_csv_from_directory', 'load_csv', 'create_data'] DEFAULT_TYPE = 'escaped' def create_data(data, class_getter, keyorder=None): """ Create the ``data``, which is the return value from ``load_csv()``. Classes will be resolved with the callable ``class_getter``; or if ``class_getter`` is a module then the class names will be attributes of that. Returns a dictionary of ``{object_name: object(s)}``, using the names from the ``[name]`` columns (if there are any). If a name is used multiple times, you get a list of objects, not a single object. If ``keyorder`` is given, then the keys will be retrieved in that order. It can be a list/tuple of names, or a sorting function. If not given and ``class_getter`` is a module and has a ``soClasses`` function, then that will be used for the order. """ objects = {} classnames = data.keys() if (not keyorder and isinstance(class_getter, types.ModuleType) and hasattr(class_getter, 'soClasses')): keyorder = [c.__name__ for c in class_getter.soClasses] if not keyorder: classnames.sort() elif isinstance(keyorder, (list, tuple)): all = classnames classnames = [name for name in keyorder if name in classnames] for name in all: if name not in classnames: classnames.append(name) else: classnames.sort(keyorder) for classname in classnames: items = data[classname] if not items: continue if isinstance(class_getter, types.ModuleType): soClass = getattr(class_getter, classname) else: soClass = class_getter(classname) for item in items: for key, value in item.items(): if isinstance(value, Reference): resolved = objects.get(value.name) if not resolved: raise ValueError( "Object reference to %r does not have target" % value.name) elif (isinstance(resolved, list) and len(resolved) > 1): raise ValueError( "Object reference to %r is ambiguous (got %r)" % (value.name, resolved)) item[key] = resolved.id if '[name]' in item: name = item.pop('[name]').strip() else: name = None inst = soClass(**item) if name: if name in objects: if isinstance(objects[name], list): objects[name].append(inst) else: objects[name] = [objects[name], inst] else: objects[name] = inst return objects def load_csv_from_directory(directory, allow_python=True, default_type=DEFAULT_TYPE, allow_multiple_classes=True): """ Load the data from all the files in a directory. Filenames indicate the class, with ``general.csv`` for data not associated with a class. Return data just like ``load_csv`` does. This might cause problems on case-insensitive filesystems. """ results = {} for filename in os.listdir(directory): base, ext = os.path.splitext(filename) if ext.lower() != '.csv': continue f = open(os.path.join(directory, filename), 'rb') csvreader = csv.reader(f) data = load_csv(csvreader, allow_python=allow_python, default_type=default_type, default_class=base, allow_multiple_classes=allow_multiple_classes) f.close() for classname, items in data.items(): results.setdefault(classname, []).extend(items) return results def load_csv(csvreader, allow_python=True, default_type=DEFAULT_TYPE, default_class=None, allow_multiple_classes=True): """ Loads the CSV file, returning a list of dictionaries with types coerced. """ current_class = default_class current_headers = None results = {} for row in csvreader: if not [cell for cell in row if cell.strip()]: # empty row continue if row and row[0].strip() == 'CLASS:': if not allow_multiple_classes: raise ValueError( "CLASS: line in CSV file, but multiple classes " "are not allowed in this file (line: %r)" % row) if not row[1:]: raise ValueError( "CLASS: in line in CSV file, with no class name " "in next column (line: %r)" % row) current_class = row[1] current_headers = None continue if not current_class: raise ValueError( "No CLASS: line given, and there is no default class " "for this file (line: %r)" % row) if current_headers is None: current_headers = _parse_headers(row, default_type, allow_python=allow_python) continue if row[0] == '[comment]': continue # Pad row with empty strings: row += [''] * (len(current_headers) - len(row)) row_converted = {} for value, (name, coercer, args) in zip(row, current_headers): if name is None: # Comment continue if value == '[default]': continue if value == '[null]': row_converted[name] = None continue args = (value,) + args row_converted[name] = coercer(*args) results.setdefault(current_class, []).append(row_converted) return results def _parse_headers(header_row, default_type, allow_python=True): headers = [] for name in header_row: original_name = name if ':' in name: name, type = name.split(':', 1) else: type = default_type if type == 'python' and not allow_python: raise ValueError( ":python header given when python headers are not allowed " "(with header %r)" % original_name) name = name.strip() if name == '[comment]' or not name: headers.append((None, None, None)) continue type = type.strip().lower() if '(' in type: type, arg = type.split('(', 1) if not arg.endswith(')'): raise ValueError( "Arguments (in ()'s) do not end with ): %r" % original_name) args = (arg[:-1],) else: args = () if name == '[name]': type = 'str' coercer, args = get_coercer(type) headers.append((name, coercer, args)) return headers _coercers = {} def get_coercer(type): if type not in _coercers: raise ValueError( "Coercion type %r not known (I know: %s)" % (type, ', '.join(_coercers.keys()))) return _coercers[type] def register_coercer(type, coercer, *args): _coercers[type] = (coercer, args) def identity(v): return v register_coercer('str', identity) register_coercer('string', identity) def decode_string(v, encoding): return v.decode(encoding) register_coercer('escaped', decode_string, 'string_escape') register_coercer('strescaped', decode_string, 'string_escape') register_coercer('base64', decode_string, 'base64') register_coercer('int', int) register_coercer('float', float) def parse_python(v): return eval(v, {}, {}) register_coercer('python', parse_python) def parse_date(v): v = v.strip() if not v: return None if v.startswith('NOW-') or v.startswith('NOW+'): days = int(v[3:]) now = date.today() return now + timedelta(days) else: parsed = time.strptime(v, '%Y-%m-%d') return date.fromtimestamp(time.mktime(parsed)) register_coercer('date', parse_date) def parse_datetime(v): v = v.strip() if not v: return None if v.startswith('NOW-') or v.startswith('NOW+'): seconds = int(v[3:]) now = datetime.now() return now + timedelta(0, seconds) else: fmts = ['%Y-%m-%dT%H:%M:%S', '%Y-%m-%d %H:%M:%S', '%Y-%m-%dT%H:%M', '%Y-%m-%d %H:%M'] for fmt in fmts[:-1]: try: parsed = time.strptime(v, fmt) break except ValueError: pass else: parsed = time.strptime(v, fmts[-1]) return datetime.fromtimestamp(time.mktime(parsed)) register_coercer('datetime', parse_datetime) class Reference(object): def __init__(self, name): self.name = name def parse_ref(v): if not v.strip(): return None else: return Reference(v) register_coercer('ref', parse_ref) def parse_bool(v): v = v.strip().lower() if v in ('y', 'yes', 't', 'true', 'on', '1'): return True elif v in ('n', 'no', 'f', 'false', 'off', '0'): return False raise ValueError( "Value is not boolean-like: %r" % v) register_coercer('bool', parse_bool) register_coercer('boolean', parse_bool) SQLObject-3.1.0/sqlobject/util/csvexport.py0000644000175000017500000001557212503207731020235 0ustar phdphd00000000000000""" Exports a SQLObject class (possibly annotated) to a CSV file. """ import csv import os try: from cStringIO import StringIO except ImportError: try: from StringIO import StringIO except ImportError: from io import StringIO, BytesIO import sqlobject from sqlobject.compat import PY2, string_type __all__ = ['export_csv', 'export_csv_zip'] def export_csv(soClass, select=None, writer=None, connection=None, orderBy=None): """ Export the SQLObject class ``soClass`` to a CSV file. ``soClass`` can also be a SelectResult object, as returned by ``.select()``. If it is a class, all objects will be retrieved, ordered by ``orderBy`` if given, or the ``.csvOrderBy`` attribute if present (but csvOrderBy will only be applied when no select result is given). You can also pass in select results (or simply a list of instances) in ``select`` -- if you have a list of objects (not a SelectResult instance, as produced by ``.select()``) then you must pass it in with ``select`` and pass the class in as the first argument. ``writer`` is a ``csv.writer()`` object, or a file-like object. If not given, the string of the file will be returned. Uses ``connection`` as the data source, if given, otherwise the default connection. Columns can be annotated with ``.csvTitle`` attributes, which will form the attributes of the columns, or 'title' (secondarily), or if nothing then the column attribute name. If a column has a ``.noCSV`` attribute which is true, then the column will be suppressed. Additionally a class can have an ``.extraCSVColumns`` attribute, which should be a list of strings/tuples. If a tuple, it should be like ``(attribute, title)``, otherwise it is the attribute, which will also be the title. These will be appended to the end of the CSV file; the attribute will be retrieved from instances. Also a ``.csvColumnOrder`` attribute can be on the class, which is the string names of attributes in the order they should be presented. """ return_fileobj = None if not writer: return_fileobj = StringIO() writer = csv.writer(return_fileobj) elif not hasattr(writer, 'writerow'): writer = csv.writer(writer) if isinstance(soClass, sqlobject.SQLObject.SelectResultsClass): assert select is None, ( "You cannot pass in a select argument (%r) " "and a SelectResult argument (%r) for soClass" % (select, soClass)) select = soClass soClass = select.sourceClass elif select is None: select = soClass.select() if getattr(soClass, 'csvOrderBy', None): select = select.orderBy(soClass.csvOrderBy) if orderBy: select = select.orderBy(orderBy) if connection: select = select.connection(connection) _actually_export_csv(soClass, select, writer) if return_fileobj: # They didn't pass any writer or file object in, so we return # the string result: return return_fileobj.getvalue() def _actually_export_csv(soClass, select, writer): attributes, titles = _find_columns(soClass) writer.writerow(titles) for soInstance in select: row = [getattr(soInstance, attr) for attr in attributes] writer.writerow(row) def _find_columns(soClass): order = [] attrs = {} for col in soClass.sqlmeta.columnList: if getattr(col, 'noCSV', False): continue order.append(col.name) title = col.name if hasattr(col, 'csvTitle'): title = col.csvTitle elif getattr(col, 'title', None) is not None: title = col.title attrs[col.name] = title for attrDesc in getattr(soClass, 'extraCSVColumns', []): if isinstance(attrDesc, (list, tuple)): attr, title = attrDesc else: attr = title = attrDesc order.append(attr) attrs[attr] = title if hasattr(soClass, 'csvColumnOrder'): oldOrder = order order = soClass.csvColumnOrder for attr in order: if attr not in oldOrder: raise KeyError( "Attribute %r in csvColumnOrder (on class %r) " "does not exist as a column or in .extraCSVColumns " "(I have: %r)" % (attr, soClass, oldOrder)) oldOrder.remove(attr) order.extend(oldOrder) titles = [attrs[attr] for attr in order] return order, titles def export_csv_zip(soClasses, file=None, zip=None, filename_prefix='', connection=None): """ Export several SQLObject classes into a .zip file. Each item in the ``soClasses`` list may be a SQLObject class, select result, or ``(soClass, select)`` tuple. Each file in the zip will be named after the class name (with ``.csv`` appended), or using the filename in the ``.csvFilename`` attribute. If ``file`` is given, the zip will be written to that. ``file`` may be a string (a filename) or a file-like object. If not given, a string will be returnd. If ``zip`` is given, then the files will be written to that zip file. All filenames will be prefixed with ``filename_prefix`` (which may be a directory name, for instance). """ import zipfile close_file_when_finished = False close_zip_when_finished = True return_when_finished = False if file: if isinstance(file, string_type): close_file_when_finished = True file = open(file, 'wb') elif zip: close_zip_when_finished = False else: return_when_finished = True if PY2: file = StringIO() else: # zipfile on python3 requires BytesIO file = BytesIO() if not zip: zip = zipfile.ZipFile(file, mode='w') try: _actually_export_classes(soClasses, zip, filename_prefix, connection) finally: if close_zip_when_finished: zip.close() if close_file_when_finished: file.close() if return_when_finished: return file.getvalue() def _actually_export_classes(soClasses, zip, filename_prefix, connection): for classDesc in soClasses: if isinstance(classDesc, (tuple, list)): soClass, select = classDesc elif isinstance(classDesc, sqlobject.SQLObject.SelectResultsClass): select = classDesc soClass = select.sourceClass else: soClass = classDesc select = None filename = getattr(soClass, 'csvFilename', soClass.__name__) if not os.path.splitext(filename)[1]: filename += '.csv' filename = filename_prefix + filename zip.writestr(filename, export_csv(soClass, select, connection=connection)) SQLObject-3.1.0/sqlobject/util/moduleloader.py0000644000175000017500000000251012465143172020645 0ustar phdphd00000000000000import imp import os import sys def load_module(module_name): mod = __import__(module_name) components = module_name.split('.') for comp in components[1:]: mod = getattr(mod, comp) return mod def load_module_from_name(filename, module_name): if module_name in sys.modules: return sys.modules[module_name] init_filename = os.path.join(os.path.dirname(filename), '__init__.py') if not os.path.exists(init_filename): try: f = open(init_filename, 'w') except (OSError, IOError) as e: raise IOError( 'Cannot write __init__.py file into directory %s (%s)\n' % (os.path.dirname(filename), e)) f.write('#\n') f.close() fp = None if module_name in sys.modules: return sys.modules[module_name] if '.' in module_name: parent_name = '.'.join(module_name.split('.')[:-1]) base_name = module_name.split('.')[-1] load_module_from_name(os.path.dirname(filename), parent_name) else: base_name = module_name fp = None try: fp, pathname, stuff = imp.find_module( base_name, [os.path.dirname(filename)]) module = imp.load_module(module_name, fp, pathname, stuff) finally: if fp is not None: fp.close() return module SQLObject-3.1.0/sqlobject/maxdb/0000755000175000017500000000000012754657361015752 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/maxdb/maxdbconnection.py0000644000175000017500000002514712466177021021476 0ustar phdphd00000000000000""" Contributed by Edigram SAS, Paris France Tel:01 44 77 94 00 Ahmed MOHAMED ALI 27 April 2004 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. connection creation sample:: __connection__ = DBConnection.maxdbConnection( host=hostname, database=dbname, user=user_name, password=user_password, autoCommit=1, debug=1) """ import os from sqlobject.dbconnection import DBAPI from sqlobject import col class maxdbException(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) class LowerBoundOfSliceIsNotSupported(maxdbException): def __init__(self, value): maxdbException.__init__(self, '') class IncorrectIDStyleError(maxdbException): def __init__(self, value): maxdbException.__init__( self, 'This primary key name is not in the expected style, ' 'please rename the column to %r or switch to another style' % value) class StyleMismatchError(maxdbException): def __init__(self, value): maxdbException.__init__( self, 'The name %r is only permitted for primary key, change the ' 'column name or switch to another style' % value) class PrimaryKeyNotFounded(maxdbException): def __init__(self, value): maxdbException.__init__( self, "No primary key was defined on table %r" % value) SAPDBMAX_ID_LENGTH = 32 class MaxdbConnection(DBAPI): supportTransactions = True dbName = 'maxdb' schemes = [dbName] def __init__(self, host='', port=None, user=None, password=None, database=None, autoCommit=1, sqlmode='internal', isolation=None, timeout=None, **kw): from sapdb import dbapi self.module = dbapi self.host = host self.port = port self.user = user self.password = password self.db = database self.autoCommit = autoCommit self.sqlmode = sqlmode self.isolation = isolation self.timeout = timeout DBAPI.__init__(self, **kw) @classmethod def _connectionFromParams(cls, auth, password, host, port, path, args): path = path.replace('/', os.path.sep) return cls(host, port, user=auth, password=password, database=path, **args) def _getConfigParams(self, sqlmode, auto): autocommit = 'off' if auto: autocommit = 'on' opt = {} opt["autocommit"] = autocommit opt["sqlmode"] = sqlmode if self.isolation: opt["isolation"] = self.isolation if self.timeout: opt["timeout"] = self.timeout return opt def _setAutoCommit(self, conn, auto): conn.close() conn.__init__(self.user, self.password, self.db, self.host, **self._getConfigParams(self.sqlmode, auto)) def createSequenceName(self, table): """ sequence name are builded with the concatenation of the table name with '_SEQ' word we truncate the name of the sequence_name because sapdb identifier cannot exceed 32 characters so that the name of the sequence does not exceed 32 characters """ return '%s_SEQ' % (table[:SAPDBMAX_ID_LENGTH - 4]) def makeConnection(self): conn = self.module.Connection( self.user, self.password, self.db, self.host, **self._getConfigParams(self.sqlmode, self.autoCommit)) return conn def _queryInsertID(self, conn, soInstance, id, names, values): table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName c = conn.cursor() if id is None: c.execute( 'SELECT %s.NEXTVAL FROM DUAL' % ( self.createSequenceName(table))) id = c.fetchone()[0] names = [idName] + names values = [id] + values q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') c.execute(q) if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id @classmethod def sqlAddLimit(cls, query, limit): sql = query sql = sql.replace("SELECT", "SELECT ROWNO, ") if sql.find('WHERE') != -1: sql = sql + ' AND ' + limit else: sql = sql + 'WHERE ' + limit return sql @classmethod def _queryAddLimitOffset(cls, query, start, end): if start: raise LowerBoundOfSliceIsNotSupported limit = ' ROWNO <= %d ' % (end) return cls.sqlAddLimit(query, limit) def createTable(self, soClass): # We create the table in a transaction because the addition of the # table and the sequence must be atomic. # I tried to use the transaction class # but I get a recursion limit error. # t=self.transaction() # t.query('CREATE TABLE %s (\n%s\n)' % # (soClass.sqlmeta.table, self.createColumns(soClass))) # # t.query("CREATE SEQUENCE %s" % # self.createSequenceName(soClass.sqlmeta.table)) # t.commit() # so use transaction when the problem will be solved self.query('CREATE TABLE %s (\n%s\n)' % (soClass.sqlmeta.table, self.createColumns(soClass))) self.query("CREATE SEQUENCE %s" % self.createSequenceName(soClass.sqlmeta.table)) return [] def createReferenceConstraint(self, soClass, col): return col.maxdbCreateReferenceConstraint() def createColumn(self, soClass, col): return col.maxdbCreateSQL() def createIDColumn(self, soClass): key_type = {int: "INT", str: "TEXT"}[soClass.sqlmeta.idType] return '%s %s PRIMARY KEY' % (soClass.sqlmeta.idName, key_type) def createIndexSQL(self, soClass, index): return index.maxdbCreateIndexSQL(soClass) def dropTable(self, tableName, cascade=False): # We drop the table in a transaction because the removal of the # table and the sequence must be atomic. # I tried to use the transaction class # but I get a recursion limit error. # try: # t=self.transaction() # t.query("DROP TABLE %s" % tableName) # t.query("DROP SEQUENCE %s" % self.createSequenceName(tableName)) # t.commit() # except: # t.rollback() # so use transaction when the problem will be solved self.query("DROP TABLE %s" % tableName) self.query("DROP SEQUENCE %s" % self.createSequenceName(tableName)) def joinSQLType(self, join): return 'INT NOT NULL' def tableExists(self, tableName): for (table,) in self.queryAll( "SELECT OBJECT_NAME FROM ALL_OBJECTS " "WHERE OBJECT_TYPE='TABLE'"): if table.lower() == tableName.lower(): return True return False def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD %s' % (tableName, column.maxdbCreateSQL())) def delColumn(self, sqlmeta, column): self.query('ALTER TABLE %s DROP COLUMN %s' % (sqlmeta.table, column.dbName)) GET_COLUMNS = """ SELECT COLUMN_NAME, NULLABLE, DATA_DEFAULT, DATA_TYPE, DATA_LENGTH, DATA_SCALE FROM USER_TAB_COLUMNS WHERE TABLE_NAME=UPPER('%s')""" GET_PK_AND_FK = """ SELECT constraint_cols.column_name, constraints.constraint_type, refname,reftablename FROM user_cons_columns constraint_cols INNER JOIN user_constraints constraints ON constraint_cols.constraint_name = constraints.constraint_name LEFT OUTER JOIN show_foreign_key fk ON constraint_cols.column_name = fk.columnname WHERE constraints.table_name =UPPER('%s')""" def columnsFromSchema(self, tableName, soClass): colData = self.queryAll(self.GET_COLUMNS % tableName) results = [] keymap = {} pkmap = {} fkData = self.queryAll(self.GET_PK_AND_FK % tableName) for _col, cons_type, refcol, reftable in fkData: col_name = _col.lower() pkmap[col_name] = False if cons_type == 'R': keymap[col_name] = reftable.lower() elif cons_type == 'P': pkmap[col_name] = True if len(pkmap) == 0: raise PrimaryKeyNotFounded(tableName) for (field, nullAllowed, default, data_type, data_len, data_scale) in colData: # id is defined as primary key --> ok # We let sqlobject raise error if the 'id' is used # for another column. field_name = field.lower() if (field_name == soClass.sqlmeta.idName) and pkmap[field_name]: continue colClass, kw = self.guessClass(data_type, data_len, data_scale) kw['name'] = field_name kw['dbName'] = field if nullAllowed == 'Y': nullAllowed = False else: nullAllowed = True kw['notNone'] = nullAllowed if default is not None: kw['default'] = default if field_name in keymap: kw['foreignKey'] = keymap[field_name] results.append(colClass(**kw)) return results _numericTypes = ['INTEGER', 'INT', 'SMALLINT'] _dateTypes = ['DATE', 'TIME', 'TIMESTAMP'] def guessClass(self, t, flength, fscale=None): """ An internal method that tries to figure out what Col subclass is appropriate given whatever introspective information is available -- both very database-specific. """ if t in self._numericTypes: return col.IntCol, {} # The type returned by the sapdb library for LONG is # SapDB_LongReader To get the data call the read member with # desired size (default =-1 means get all) elif t.find('LONG') != -1: return col.StringCol, {'length': flength, 'varchar': False} elif t in self._dateTypes: return col.DateTimeCol, {} elif t == 'FIXED': return col.CurrencyCol, {'size': flength, 'precision': fscale} else: return col.Col, {} SQLObject-3.1.0/sqlobject/maxdb/__init__.py0000644000175000017500000000030512464733165020054 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import maxdbconnection return maxdbconnection.MaxdbConnection registerConnection(['maxdb', 'sapdb'], builder) SQLObject-3.1.0/sqlobject/maxdb/readme.txt0000644000175000017500000000125610063265525017740 0ustar phdphd00000000000000This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Author: Edigram SA - Paris France Tel:0144779400 SAPDBAPI installation --------------------- The sapdb module can be downloaded from: Win32 ------- ftp://ftp.sap.com/pub/sapdb/bin/win/sapdb-python-win32-7.4.03.31a.zip Linux ------ ftp://ftp.sap.com/pub/sapdb/bin/linux/sapdb-python-linux-i386-7.4.03.31a.tgz uncompress the archive and add the sapdb directory path to your PYTHONPATH. SQLObject-3.1.0/sqlobject/index.py0000644000175000017500000001470012470115365016326 0ustar phdphd00000000000000from itertools import count from .converters import sqlrepr creationOrder = count() class SODatabaseIndex(object): def __init__(self, soClass, name, columns, creationOrder, unique=False): self.soClass = soClass self.name = name self.descriptions = self.convertColumns(columns) self.creationOrder = creationOrder self.unique = unique def get(self, *args, **kw): if not self.unique: raise AttributeError( "'%s' object has no attribute 'get' " "(index is not unique)" % self.name) connection = kw.pop('connection', None) if args and kw: raise TypeError("You cannot mix named and unnamed arguments") columns = [d['column'] for d in self.descriptions if 'column' in d] if kw and len(kw) != len(columns) or \ args and len(args) != len(columns): raise TypeError( "get() takes exactly %d argument and an optional " "named argument 'connection' (%d given)" % ( len(columns), len(args) + len(kw))) if args: kw = {} for i in range(len(args)): if columns[i].foreignName is not None: kw[columns[i].foreignName] = args[i] else: kw[columns[i].name] = args[i] return self.soClass.selectBy(connection=connection, **kw).getOne() def convertColumns(self, columns): """ Converts all the columns to dictionary descriptors; dereferences string column names. """ new = [] for desc in columns: if not isinstance(desc, dict): desc = {'column': desc} if 'expression' in desc: assert 'column' not in desc, ( 'You cannot provide both an expression and a column ' '(for %s in index %s in %s)' % (desc, self.name, self.soClass)) assert 'length' not in desc, ( 'length does not apply to expressions (for %s in ' 'index %s in %s)' % (desc, self.name, self.soClass)) new.append(desc) continue columnName = desc['column'] if not isinstance(columnName, str): columnName = columnName.name colDict = self.soClass.sqlmeta.columns if columnName not in colDict: for possible in colDict.values(): if possible.origName == columnName: column = possible break else: # None found raise ValueError( "The column by the name %r was not found " "in the class %r" % (columnName, self.soClass)) else: column = colDict[columnName] desc['column'] = column new.append(desc) return new def getExpression(self, desc, db): if isinstance(desc['expression'], str): return desc['expression'] else: return sqlrepr(desc['expression'], db) def sqliteCreateIndexSQL(self, soClass): if self.unique: uniqueOrIndex = 'UNIQUE INDEX' else: uniqueOrIndex = 'INDEX' spec = [] for desc in self.descriptions: if 'expression' in desc: spec.append(self.getExpression(desc, 'sqlite')) else: spec.append(desc['column'].dbName) ret = 'CREATE %s %s_%s ON %s (%s)' % \ (uniqueOrIndex, self.soClass.sqlmeta.table, self.name, self.soClass.sqlmeta.table, ', '.join(spec)) return ret postgresCreateIndexSQL = maxdbCreateIndexSQL = mssqlCreateIndexSQL = \ sybaseCreateIndexSQL = firebirdCreateIndexSQL = sqliteCreateIndexSQL def mysqlCreateIndexSQL(self, soClass): if self.unique: uniqueOrIndex = 'UNIQUE' else: uniqueOrIndex = 'INDEX' spec = [] for desc in self.descriptions: if 'expression' in desc: spec.append(self.getExpression(desc, 'mysql')) elif 'length' in desc: spec.append('%s(%d)' % (desc['column'].dbName, desc['length'])) else: spec.append(desc['column'].dbName) return 'ALTER TABLE %s ADD %s %s (%s)' % \ (soClass.sqlmeta.table, uniqueOrIndex, self.name, ', '.join(spec)) class DatabaseIndex(object): """ This takes a variable number of parameters, each of which is a column for indexing. Each column may be a column object or the string name of the column (*not* the database name). You may also use dictionaries, to further customize the indexing of the column. The dictionary may have certain keys: 'column': The column object or string identifier. 'length': MySQL will only index the first N characters if this is given. For other databases this is ignored. 'expression': You can create an index based on an expression, e.g., 'lower(column)'. This can either be a string or a sqlbuilder expression. Further keys may be added to the column specs in the future. The class also take the keyword argument `unique`; if true then a UNIQUE index is created. """ baseClass = SODatabaseIndex def __init__(self, *columns, **kw): kw['columns'] = columns self.kw = kw self.creationOrder = next(creationOrder) def setName(self, value): assert self.kw.get('name') is None, \ "You cannot change a name after it has already been set " \ "(from %s to %s)" % (self.kw['name'], value) self.kw['name'] = value def _get_name(self): return self.kw['name'] def _set_name(self, value): self.setName(value) name = property(_get_name, _set_name) def withClass(self, soClass): return self.baseClass(soClass=soClass, creationOrder=self.creationOrder, **self.kw) def __repr__(self): return '<%s %s %s>' % ( self.__class__.__name__, hex(abs(id(self)))[2:], self.kw) __all__ = ['DatabaseIndex'] SQLObject-3.1.0/sqlobject/classregistry.py0000644000175000017500000001146112470415717020122 0ustar phdphd00000000000000""" classresolver.py 2 February 2004, Ian Bicking Resolves strings to classes, and runs callbacks when referenced classes are created. Classes are referred to only by name, not by module. So that identically-named classes can coexist, classes are put into individual registries, which are keyed on strings (names). These registries are created on demand. Use like:: >>> import classregistry >>> registry = classregistry.registry('MyModules') >>> def afterMyClassExists(cls): ... print('Class finally exists: %s' % cls) >>> registry.addClassCallback('MyClass', afterMyClassExists) >>> class MyClass: ... pass >>> registry.addClass(MyClass) Class finally exists: MyClass """ class ClassRegistry(object): """ We'll be dealing with classes that reference each other, so class C1 may reference C2 (in a join), while C2 references C1 right back. Since classes are created in an order, there will be a point when C1 exists but C2 doesn't. So we deal with classes by name, and after each class is created we try to fix up any references by replacing the names with actual classes. Here we keep a dictionaries of class names to classes -- note that the classes might be spread among different modules, so since we pile them together names need to be globally unique, to just module unique. Like needSet below, the container dictionary is keyed by the class registry. """ def __init__(self, name): self.name = name self.classes = {} self.callbacks = {} self.genericCallbacks = [] def addClassCallback(self, className, callback, *args, **kw): """ Whenever a name is substituted for the class, you can register a callback that will be called when the needed class is created. If it's already been created, the callback will be called immediately. """ if className in self.classes: callback(self.classes[className], *args, **kw) else: self.callbacks.setdefault(className, []).append( (callback, args, kw)) def addCallback(self, callback, *args, **kw): """ This callback is called for all classes, not just specific ones (like addClassCallback). """ self.genericCallbacks.append((callback, args, kw)) for cls in self.classes.values(): callback(cls, *args, **kw) def addClass(self, cls): """ Everytime a class is created, we add it to the registry, so that other classes can find it by name. We also call any callbacks that are waiting for the class. """ if cls.__name__ in self.classes: import sys other = self.classes[cls.__name__] raise ValueError( "class %s is already in the registry (other class is " "%r, from the module %s in %s; attempted new class is " "%r, from the module %s in %s)" % (cls.__name__, other, other.__module__, getattr(sys.modules.get(other.__module__), '__file__', '(unknown)'), cls, cls.__module__, getattr(sys.modules.get(cls.__module__), '__file__', '(unknown)'))) self.classes[cls.__name__] = cls if cls.__name__ in self.callbacks: for callback, args, kw in self.callbacks[cls.__name__]: callback(cls, *args, **kw) del self.callbacks[cls.__name__] for callback, args, kw in self.genericCallbacks: callback(cls, *args, **kw) def getClass(self, className): try: return self.classes[className] except KeyError: all = sorted(self.classes.keys()) raise KeyError( "No class %s found in the registry %s (these classes " "exist: %s)" % (className, self.name or '[default]', ', '.join(all))) def allClasses(self): return self.classes.values() class _MasterRegistry(object): """ This singleton holds all the class registries. There can be multiple registries to hold different unrelated sets of classes that reside in the same process. These registries are named with strings, and are created on demand. The MasterRegistry module global holds the singleton. """ def __init__(self): self.registries = {} def registry(self, item): if item not in self.registries: self.registries[item] = ClassRegistry(item) return self.registries[item] MasterRegistry = _MasterRegistry() registry = MasterRegistry.registry def findClass(name, class_registry=None): return registry(class_registry).getClass(name) SQLObject-3.1.0/sqlobject/compat.py0000644000175000017500000000163012735240476016506 0ustar phdphd00000000000000import sys import types # Credit to six authors: https://pypi.python.org/pypi/six # License: MIT def with_metaclass(meta, *bases): """Create a base class with a metaclass.""" # This requires a bit of explanation: the basic idea is to make a dummy # metaclass for one level of class instantiation that replaces itself with # the actual metaclass. class metaclass(meta): def __new__(cls, name, this_bases, d): return meta(name, bases, d) return type.__new__(metaclass, 'temporary_class', (), {}) # Compatability definitions (inspired by six) PY2 = sys.version_info[0] < 3 if PY2: # disable flake8 checks on python 3 string_type = basestring # noqa unicode_type = unicode # noqa class_types = (type, types.ClassType) buffer_type = buffer # noqa else: string_type = str unicode_type = str class_types = (type,) buffer_type = memoryview SQLObject-3.1.0/sqlobject/joins.py0000644000175000017500000004437212473144200016342 0ustar phdphd00000000000000from itertools import count from . import boundattributes from . import classregistry from . import events from . import styles from . import sqlbuilder from .styles import capword __all__ = ['MultipleJoin', 'SQLMultipleJoin', 'RelatedJoin', 'SQLRelatedJoin', 'SingleJoin', 'ManyToMany', 'OneToMany'] creationOrder = count() NoDefault = sqlbuilder.NoDefault def getID(obj): try: return obj.id except AttributeError: return int(obj) class Join(object): def __init__(self, otherClass=None, **kw): kw['otherClass'] = otherClass self.kw = kw self._joinMethodName = self.kw.pop('joinMethodName', None) self.creationOrder = next(creationOrder) def _set_joinMethodName(self, value): assert self._joinMethodName == value or self._joinMethodName is None, \ "You have already given an explicit joinMethodName (%s), " \ "and you are now setting it to %s" % (self._joinMethodName, value) self._joinMethodName = value def _get_joinMethodName(self): return self._joinMethodName joinMethodName = property(_get_joinMethodName, _set_joinMethodName) name = joinMethodName def withClass(self, soClass): if 'joinMethodName' in self.kw: self._joinMethodName = self.kw['joinMethodName'] del self.kw['joinMethodName'] return self.baseClass(creationOrder=self.creationOrder, soClass=soClass, joinDef=self, joinMethodName=self._joinMethodName, **self.kw) # A join is separate from a foreign key, i.e., it is # many-to-many, or one-to-many where the *other* class # has the foreign key. class SOJoin(object): def __init__(self, creationOrder, soClass=None, otherClass=None, joinColumn=None, joinMethodName=None, orderBy=NoDefault, joinDef=None): self.creationOrder = creationOrder self.soClass = soClass self.joinDef = joinDef self.otherClassName = otherClass classregistry.registry(soClass.sqlmeta.registry).addClassCallback( otherClass, self._setOtherClass) self.joinColumn = joinColumn self.joinMethodName = joinMethodName self._orderBy = orderBy if not self.joinColumn: # Here we set up the basic join, which is # one-to-many, where the other class points to # us. self.joinColumn = styles.getStyle( self.soClass).tableReference(self.soClass.sqlmeta.table) def orderBy(self): if self._orderBy is NoDefault: self._orderBy = self.otherClass.sqlmeta.defaultOrder return self._orderBy orderBy = property(orderBy) def _setOtherClass(self, cls): self.otherClass = cls def hasIntermediateTable(self): return False def _applyOrderBy(self, results, defaultSortClass): if self.orderBy is not None: doSort(results, self.orderBy) return results class MinType(object): """Sort less than everything, for handling None's in the results""" # functools.total_ordering would simplify this, but isn't available # for python 2.6 def __lt__(self, other): if self is other: return False return True def __eq__(self, other): return self is other def __gt__(self, other): return False def __le__(self, other): return True def __ge__(self, other): if self is other: return True return False Min = MinType() def doSort(results, orderBy): if isinstance(orderBy, (tuple, list)): if len(orderBy) == 1: orderBy = orderBy[0] else: # Rely on stable sort results, since this is simpler # than trying to munge everything into a single sort key doSort(results, orderBy[0]) doSort(results, orderBy[1:]) return if isinstance(orderBy, sqlbuilder.DESC) \ and isinstance(orderBy.expr, sqlbuilder.SQLObjectField): orderBy = '-' + orderBy.expr.original elif isinstance(orderBy, sqlbuilder.SQLObjectField): orderBy = orderBy.original # @@: but we don't handle more complex expressions for orderings if orderBy.startswith('-'): orderBy = orderBy[1:] reverse = True else: reverse = False def sortkey(x, attr=orderBy): a = getattr(x, attr) if a is None: return Min return a results.sort(key=sortkey, reverse=reverse) # This is a one-to-many class SOMultipleJoin(SOJoin): def __init__(self, addRemoveName=None, **kw): # addRemovePrefix is something like @@ SOJoin.__init__(self, **kw) # Here we generate the method names if not self.joinMethodName: name = self.otherClassName[0].lower() + self.otherClassName[1:] if name.endswith('s'): name = name + "es" else: name = name + "s" self.joinMethodName = name if addRemoveName: self.addRemoveName = addRemoveName else: self.addRemoveName = capword(self.otherClassName) def performJoin(self, inst): ids = inst._connection._SO_selectJoin( self.otherClass, self.joinColumn, inst.id) if inst.sqlmeta._perConnection: conn = inst._connection else: conn = None return self._applyOrderBy( [self.otherClass.get(id, conn) for (id,) in ids if id is not None], self.otherClass) def _dbNameToPythonName(self): for column in self.otherClass.sqlmeta.columns.values(): if column.dbName == self.joinColumn: return column.name return self.soClass.sqlmeta.style.dbColumnToPythonAttr(self.joinColumn) class MultipleJoin(Join): baseClass = SOMultipleJoin class SOSQLMultipleJoin(SOMultipleJoin): def performJoin(self, inst): if inst.sqlmeta._perConnection: conn = inst._connection else: conn = None pythonColumn = self._dbNameToPythonName() results = self.otherClass.select( getattr(self.otherClass.q, pythonColumn) == inst.id, connection=conn) return results.orderBy(self.orderBy) class SQLMultipleJoin(Join): baseClass = SOSQLMultipleJoin # This is a many-to-many join, with an intermediary table class SORelatedJoin(SOMultipleJoin): def __init__(self, otherColumn=None, intermediateTable=None, createRelatedTable=True, **kw): self.intermediateTable = intermediateTable self.otherColumn = otherColumn self.createRelatedTable = createRelatedTable SOMultipleJoin.__init__(self, **kw) classregistry.registry( self.soClass.sqlmeta.registry).addClassCallback( self.otherClassName, self._setOtherRelatedClass) def _setOtherRelatedClass(self, otherClass): if not self.intermediateTable: names = [self.soClass.sqlmeta.table, otherClass.sqlmeta.table] names.sort() self.intermediateTable = '%s_%s' % (names[0], names[1]) if not self.otherColumn: self.otherColumn = self.soClass.sqlmeta.style.tableReference( otherClass.sqlmeta.table) def hasIntermediateTable(self): return True def performJoin(self, inst): ids = inst._connection._SO_intermediateJoin( self.intermediateTable, self.otherColumn, self.joinColumn, inst.id) if inst.sqlmeta._perConnection: conn = inst._connection else: conn = None return self._applyOrderBy( [self.otherClass.get(id, conn) for (id,) in ids if id is not None], self.otherClass) def remove(self, inst, other): inst._connection._SO_intermediateDelete( self.intermediateTable, self.joinColumn, getID(inst), self.otherColumn, getID(other)) def add(self, inst, other): inst._connection._SO_intermediateInsert( self.intermediateTable, self.joinColumn, getID(inst), self.otherColumn, getID(other)) class RelatedJoin(MultipleJoin): baseClass = SORelatedJoin # helper classes to SQLRelatedJoin class OtherTableToJoin(sqlbuilder.SQLExpression): def __init__(self, otherTable, otherIdName, interTable, joinColumn): self.otherTable = otherTable self.otherIdName = otherIdName self.interTable = interTable self.joinColumn = joinColumn def tablesUsedImmediate(self): return [self.otherTable, self.interTable] def __sqlrepr__(self, db): return '%s.%s = %s.%s' % (self.otherTable, self.otherIdName, self.interTable, self.joinColumn) class JoinToTable(sqlbuilder.SQLExpression): def __init__(self, table, idName, interTable, joinColumn): self.table = table self.idName = idName self.interTable = interTable self.joinColumn = joinColumn def tablesUsedImmediate(self): return [self.table, self.interTable] def __sqlrepr__(self, db): return '%s.%s = %s.%s' % (self.interTable, self.joinColumn, self.table, self.idName) class TableToId(sqlbuilder.SQLExpression): def __init__(self, table, idName, idValue): self.table = table self.idName = idName self.idValue = idValue def tablesUsedImmediate(self): return [self.table] def __sqlrepr__(self, db): return '%s.%s = %s' % (self.table, self.idName, self.idValue) class SOSQLRelatedJoin(SORelatedJoin): def performJoin(self, inst): if inst.sqlmeta._perConnection: conn = inst._connection else: conn = None results = self.otherClass.select(sqlbuilder.AND( OtherTableToJoin( self.otherClass.sqlmeta.table, self.otherClass.sqlmeta.idName, self.intermediateTable, self.otherColumn ), JoinToTable( self.soClass.sqlmeta.table, self.soClass.sqlmeta.idName, self.intermediateTable, self.joinColumn ), TableToId(self.soClass.sqlmeta.table, self.soClass.sqlmeta.idName, inst.id), ), clauseTables=(self.soClass.sqlmeta.table, self.otherClass.sqlmeta.table, self.intermediateTable), connection=conn) return results.orderBy(self.orderBy) class SQLRelatedJoin(RelatedJoin): baseClass = SOSQLRelatedJoin class SOSingleJoin(SOMultipleJoin): def __init__(self, **kw): self.makeDefault = kw.pop('makeDefault', False) SOMultipleJoin.__init__(self, **kw) def performJoin(self, inst): if inst.sqlmeta._perConnection: conn = inst._connection else: conn = None pythonColumn = self._dbNameToPythonName() results = self.otherClass.select( getattr(self.otherClass.q, pythonColumn) == inst.id, connection=conn ) if results.count() == 0: if not self.makeDefault: return None else: kw = {self.soClass.sqlmeta.style. instanceIDAttrToAttr(pythonColumn): inst} # instanciating the otherClass with all return self.otherClass(**kw) else: return results[0] class SingleJoin(Join): baseClass = SOSingleJoin class SOManyToMany(object): def __init__(self, soClass, name, join, intermediateTable, joinColumn, otherColumn, createJoinTable, **attrs): self.name = name self.intermediateTable = intermediateTable self.joinColumn = joinColumn self.otherColumn = otherColumn self.createJoinTable = createJoinTable self.soClass = self.otherClass = None for name, value in attrs.items(): setattr(self, name, value) classregistry.registry( soClass.sqlmeta.registry).addClassCallback( join, self._setOtherClass) classregistry.registry( soClass.sqlmeta.registry).addClassCallback( soClass.__name__, self._setThisClass) def _setThisClass(self, soClass): self.soClass = soClass if self.soClass and self.otherClass: self._finishSet() def _setOtherClass(self, otherClass): self.otherClass = otherClass if self.soClass and self.otherClass: self._finishSet() def _finishSet(self): if self.intermediateTable is None: names = [self.soClass.sqlmeta.table, self.otherClass.sqlmeta.table] names.sort() self.intermediateTable = '%s_%s' % (names[0], names[1]) if not self.otherColumn: self.otherColumn = self.soClass.sqlmeta.style.tableReference( self.otherClass.sqlmeta.table) if not self.joinColumn: self.joinColumn = styles.getStyle( self.soClass).tableReference(self.soClass.sqlmeta.table) events.listen(self.event_CreateTableSignal, self.soClass, events.CreateTableSignal) events.listen(self.event_CreateTableSignal, self.otherClass, events.CreateTableSignal) self.clause = ( (self.otherClass.q.id == sqlbuilder.Field(self.intermediateTable, self.otherColumn)) & (sqlbuilder.Field(self.intermediateTable, self.joinColumn) == self.soClass.q.id)) def __get__(self, obj, type): if obj is None: return self query = ( (self.otherClass.q.id == sqlbuilder.Field(self.intermediateTable, self.otherColumn)) & (sqlbuilder.Field(self.intermediateTable, self.joinColumn) == obj.id)) select = self.otherClass.select(query) return _ManyToManySelectWrapper(obj, self, select) def event_CreateTableSignal(self, soClass, connection, extra_sql, post_funcs): if self.createJoinTable: post_funcs.append(self.event_CreateTableSignalPost) def event_CreateTableSignalPost(self, soClass, connection): if connection.tableExists(self.intermediateTable): return connection._SO_createJoinTable(self) class ManyToMany(boundattributes.BoundFactory): factory_class = SOManyToMany __restrict_attributes__ = ( 'join', 'intermediateTable', 'joinColumn', 'otherColumn', 'createJoinTable') __unpackargs__ = ('join',) # Default values: intermediateTable = None joinColumn = None otherColumn = None createJoinTable = True class _ManyToManySelectWrapper(object): def __init__(self, forObject, join, select): self.forObject = forObject self.join = join self.select = select def __getattr__(self, attr): # @@: This passes through private variable access too... should it? # Also magic methods, like __str__ return getattr(self.select, attr) def __repr__(self): return '<%s for: %s>' % (self.__class__.__name__, repr(self.select)) def __str__(self): return str(self.select) def __iter__(self): return iter(self.select) def __getitem__(self, key): return self.select[key] def add(self, obj): obj._connection._SO_intermediateInsert( self.join.intermediateTable, self.join.joinColumn, getID(self.forObject), self.join.otherColumn, getID(obj)) def remove(self, obj): obj._connection._SO_intermediateDelete( self.join.intermediateTable, self.join.joinColumn, getID(self.forObject), self.join.otherColumn, getID(obj)) def create(self, **kw): obj = self.join.otherClass(**kw) self.add(obj) return obj class SOOneToMany(object): def __init__(self, soClass, name, join, joinColumn, **attrs): self.soClass = soClass self.name = name self.joinColumn = joinColumn for name, value in attrs.items(): setattr(self, name, value) classregistry.registry( soClass.sqlmeta.registry).addClassCallback( join, self._setOtherClass) def _setOtherClass(self, otherClass): self.otherClass = otherClass if not self.joinColumn: self.joinColumn = styles.getStyle( self.soClass).tableReference(self.soClass.sqlmeta.table) self.clause = ( sqlbuilder.Field(self.otherClass.sqlmeta.table, self.joinColumn) == self.soClass.q.id) def __get__(self, obj, type): if obj is None: return self query = ( sqlbuilder.Field(self.otherClass.sqlmeta.table, self.joinColumn) == obj.id) select = self.otherClass.select(query) return _OneToManySelectWrapper(obj, self, select) class OneToMany(boundattributes.BoundFactory): factory_class = SOOneToMany __restrict_attributes__ = ( 'join', 'joinColumn') __unpackargs__ = ('join',) # Default values: joinColumn = None class _OneToManySelectWrapper(object): def __init__(self, forObject, join, select): self.forObject = forObject self.join = join self.select = select def __getattr__(self, attr): # @@: This passes through private variable access too... should it? # Also magic methods, like __str__ return getattr(self.select, attr) def __repr__(self): return '<%s for: %s>' % (self.__class__.__name__, repr(self.select)) def __str__(self): return str(self.select) def __iter__(self): return iter(self.select) def __getitem__(self, key): return self.select[key] def create(self, **kw): kw[self.join.joinColumn] = self.forObject.id return self.join.otherClass(**kw) SQLObject-3.1.0/sqlobject/conftest.py0000644000175000017500000000450312467741430017050 0ustar phdphd00000000000000""" This module is used by py.test to configure testing for this application. """ import py import sqlobject try: import pkg_resources except ImportError: # Python 2.2 pass else: pkg_resources.require('SQLObject') # Override some options (doesn't override command line): verbose = 0 exitfirst = True connectionShortcuts = { 'mysql': 'mysql://test@localhost/test', 'dbm': 'dbm:///data', 'postgres': 'postgres:///test', 'postgresql': 'postgres:///test', 'rdbhost': 'rdhbost://role:authcode@www.rdbhost.com/', 'pygresql': 'pygresql://localhost/test', 'sqlite': 'sqlite:/:memory:', 'sybase': 'sybase://test:test123@sybase/test?autoCommit=0', 'firebird': 'firebird://sysdba:masterkey@localhost/var/lib/firebird/data/test.gdb', 'mssql': 'mssql://sa:@127.0.0.1/test' } def pytest_addoption(parser): """Add the SQLObject options""" parser.addoption( '-D', '--Database', action="store", dest="Database", default='sqlite', help="The database to run the tests under (default sqlite). " "Can also use an alias from: %s" % (', '.join(connectionShortcuts.keys()))) parser.addoption( '-S', '--SQL', action="store_true", dest="show_sql", default=False, help="Show SQL from statements (when capturing stdout the " "SQL is only displayed when a test fails)") parser.addoption( '-O', '--SQL-output', action="store_true", dest="show_sql_output", default=False, help="Show output from SQL statements (when capturing " "stdout the output is only displayed when a test fails)") parser.addoption( '-E', '--events', action="store_true", dest="debug_events", default=False, help="Debug events (print information about events as they are " "sent)") option = None def pytest_configure(config): """Make cmdline arguments available to dbtest""" global option option = config.option class SQLObjectClass(py.test.collect.Class): def run(self): if (isinstance(self.obj, type) and issubclass(self.obj, sqlobject.SQLObject)): return [] return super(SQLObjectClass, self).run() Class = SQLObjectClass def setup_tests(): if option.debug_events: from sqlobject import events events.debug_events() SQLObject-3.1.0/sqlobject/firebird/0000755000175000017500000000000012754657361016445 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/firebird/__init__.py0000644000175000017500000000032512464733165020551 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import firebirdconnection return firebirdconnection.FirebirdConnection registerConnection(['firebird', 'interbase'], builder) SQLObject-3.1.0/sqlobject/firebird/firebirdconnection.py0000644000175000017500000004276212501065406022657 0ustar phdphd00000000000000import os import re import warnings from sqlobject import col from sqlobject.dbconnection import DBAPI class FirebirdConnection(DBAPI): supportTransactions = False dbName = 'firebird' schemes = [dbName] limit_re = re.compile('^\s*(select )(.*)', re.IGNORECASE) def __init__(self, host, db, port='3050', user='sysdba', password='masterkey', autoCommit=1, dialect=None, role=None, charset=None, **kw): try: import fdb self.module = fdb except ImportError: import kinterbasdb # See http://kinterbasdb.sourceforge.net/dist_docs/usage.html # for an explanation; in short: use datetime, decimal and # unicode. kinterbasdb.init(type_conv=200) self.module = kinterbasdb self.host = host self.port = port self.db = db self.user = user self.password = password if dialect: self.dialect = int(dialect) else: self.dialect = None self.role = role if charset: # Encoding defined by user in the connection string. self.dbEncoding = charset.replace('-', '') else: self.dbEncoding = charset # Encoding defined during database creation and stored in the database. self.defaultDbEncoding = '' DBAPI.__init__(self, **kw) @classmethod def _connectionFromParams(cls, auth, password, host, port, path, args): if not password: password = 'masterkey' if not auth: auth = 'sysdba' # check for alias using if (path[0] == '/') and path[-3:].lower() not in ('fdb', 'gdb'): path = path[1:] path = path.replace('/', os.sep) return cls(host, port=port, db=path, user=auth, password=password, **args) def _runWithConnection(self, meth, *args): if not self.autoCommit: return DBAPI._runWithConnection(self, meth, args) conn = self.getConnection() # @@: Horrible auto-commit implementation. Just horrible! try: conn.begin() except self.module.ProgrammingError: pass try: val = meth(conn, *args) try: conn.commit() except self.module.ProgrammingError: pass finally: self.releaseConnection(conn) return val def _setAutoCommit(self, conn, auto): # Only _runWithConnection does "autocommit", so we don't # need to worry about that. pass def makeConnection(self): extra = {} if self.dialect: extra['dialect'] = self.dialect return self.module.connect( host=self.host, port=self.port, database=self.db, user=self.user, password=self.password, role=self.role, charset=self.dbEncoding, **extra ) def _queryInsertID(self, conn, soInstance, id, names, values): """Firebird uses 'generators' to create new ids for a table. The users needs to create a generator named GEN_ for each table this method to work.""" table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName sequenceName = soInstance.sqlmeta.idSequence or 'GEN_%s' % table c = conn.cursor() if id is None: c.execute('SELECT gen_id(%s,1) FROM rdb$database' % sequenceName) id = c.fetchone()[0] names = [idName] + names values = [id] + values q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') c.execute(q) if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id @classmethod def _queryAddLimitOffset(cls, query, start, end): """Firebird slaps the limit and offset (actually 'first' and 'skip', respectively) statement right after the select.""" if not start: limit_str = "SELECT FIRST %i" % end if not end: limit_str = "SELECT SKIP %i" % start else: limit_str = "SELECT FIRST %i SKIP %i" % (end - start, start) match = cls.limit_re.match(query) if match and len(match.groups()) == 2: return ' '.join([limit_str, match.group(2)]) else: return query def createTable(self, soClass): self.query('CREATE TABLE %s (\n%s\n)' % (soClass.sqlmeta.table, self.createColumns(soClass))) self.query("CREATE GENERATOR GEN_%s" % soClass.sqlmeta.table) return [] def createReferenceConstraint(self, soClass, col): return None def createColumn(self, soClass, col): return col.firebirdCreateSQL() def createIDColumn(self, soClass): key_type = {int: "INT", str: "TEXT"}[soClass.sqlmeta.idType] return '%s %s NOT NULL PRIMARY KEY' % (soClass.sqlmeta.idName, key_type) def createIndexSQL(self, soClass, index): return index.firebirdCreateIndexSQL(soClass) def joinSQLType(self, join): return 'INT NOT NULL' def tableExists(self, tableName): # there's something in the database by this name...let's # assume it's a table. By default, fb 1.0 stores EVERYTHING # it cares about in uppercase. result = self.queryOne( "SELECT COUNT(rdb$relation_name) FROM rdb$relations " "WHERE rdb$relation_name = '%s'" % tableName.upper()) return result[0] def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD %s' % (tableName, column.firebirdCreateSQL())) def dropTable(self, tableName, cascade=False): self.query("DROP TABLE %s" % tableName) self.query("DROP GENERATOR GEN_%s" % tableName) def delColumn(self, sqlmeta, column): self.query('ALTER TABLE %s DROP %s' % (sqlmeta.table, column.dbName)) def readDefaultEncodingFromDB(self): # Get out if encoding is known allready (can by None as well). if self.defaultDbEncoding == "": self.defaultDbEncoding = str(self.queryOne( "SELECT rdb$character_set_name FROM rdb$database")[0]. strip().lower()) # encoding defined during db creation if self.defaultDbEncoding == "none": self.defaultDbEncoding = None if self.dbEncoding != self.defaultDbEncoding: warningText = """\n Database charset: %s is different """ \ """from connection charset: %s.\n""" % ( self.defaultDbEncoding, self.dbEncoding) warnings.warn(warningText) # TODO: ??? print out the uri string, # so user can see what is going on warningText = """\n Every CHAR or VARCHAR field can (or, better: must) """ \ """have a character set defined in Firebird. In the case, field charset is not defined, """ \ """SQLObject try to use a db default encoding instead. Firebird is unable to transliterate between character sets. So you must set the correct values on the server """ \ "and on the client if everything is to work smoothely.\n" warnings.warn(warningText) if not self.dbEncoding: # defined by user in the connection string self.dbEncoding = self.defaultDbEncoding warningText = """\n encoding: %s will be used as default """ \ """for this connection\n""" % self.dbEncoding warnings.warn(warningText) def columnsFromSchema(self, tableName, soClass): """ Look at the given table and create Col instances (or subclasses of Col) for the fields it finds in that table. """ self.readDefaultEncodingFromDB() fieldQuery = """\ SELECT r.RDB$FIELD_NAME AS field_name, CASE f.RDB$FIELD_TYPE when 7 then 'smallint' when 8 then 'integer' when 16 then 'int64' when 9 then 'quad' when 10 then 'float' when 11 then 'd_float' when 17 then 'boolean' when 27 then 'double' when 12 then 'date' when 13 then 'time' when 35 then 'timestamp' when 261 then 'blob' when 37 then 'varchar' when 14 then 'char' when 40 then 'cstring' when 45 then 'blob_id' ELSE 'UNKNOWN' END AS field_type, case f.rdb$field_type when 7 then case f.rdb$field_sub_type when 1 then 'numeric' when 2 then 'decimal' end when 8 then case f.rdb$field_sub_type when 1 then 'numeric' when 2 then 'decimal' end when 16 then case f.rdb$field_sub_type when 1 then 'numeric' when 2 then 'decimal' else 'bigint' end when 14 then case f.rdb$field_sub_type when 0 then 'unspecified' when 1 then 'binary' when 3 then 'acl' else case when f.rdb$field_sub_type is null then 'unspecified' end end when 37 then case f.rdb$field_sub_type when 0 then 'unspecified' when 1 then 'text' when 3 then 'acl' else case when f.rdb$field_sub_type is null then 'unspecified' end end when 261 then case f.rdb$field_sub_type when 0 then 'unspecified' when 1 then 'text' when 2 then 'blr' when 3 then 'acl' when 4 then 'reserved' when 5 then 'encoded-meta-data' when 6 then 'irregular-finished-multi-db-tx' when 7 then 'transactional_description' when 8 then 'external_file_description' end end as "ActualSubType", f.RDB$FIELD_LENGTH AS field_length, f.RDB$FIELD_PRECISION AS field_precision, f.RDB$FIELD_SCALE AS field_scale, cset.RDB$CHARACTER_SET_NAME AS field_charset, coll.RDB$COLLATION_NAME AS field_collation, r.rdb$default_source, r.RDB$NULL_FLAG AS field_not_null_constraint, r.RDB$DESCRIPTION AS field_description FROM RDB$RELATION_FIELDS r LEFT JOIN RDB$FIELDS f ON r.RDB$FIELD_SOURCE = f.RDB$FIELD_NAME LEFT JOIN RDB$COLLATIONS coll ON f.RDB$COLLATION_ID = coll.RDB$COLLATION_ID LEFT JOIN RDB$CHARACTER_SETS cset ON f.RDB$CHARACTER_SET_ID = cset.RDB$CHARACTER_SET_ID WHERE r.RDB$RELATION_NAME='%s' -- table name ORDER BY r.RDB$FIELD_POSITION """ colData = self.queryAll(fieldQuery % tableName.upper()) results = [] for (field, fieldType, fieldSubtype, fieldLength, fieldPrecision, fieldScale, fieldCharset, collationName, defaultSource, fieldNotNullConstraint, fieldDescription) in colData: field = field.strip().lower() fieldType = fieldType.strip() if fieldCharset: fieldCharset = str(fieldCharset.strip()) # 'UNICODE_FSS' is less strict # Firebird/Interbase UTF8 definition if fieldCharset.startswith('UNICODE_FSS'): fieldCharset = "UTF8" if fieldSubtype: fieldSubtype = fieldSubtype.strip() if fieldType == "int64": fieldType = fieldSubtype # can look like: "DEFAULT 0", "DEFAULT 'default text'", None if defaultSource: defaultSource = defaultSource.split(' ')[1] if defaultSource.startswith("'") and \ defaultSource.endswith("'"): defaultSource = str(defaultSource[1:-1]) elif fieldType in ("integer", "smallint", "bigint"): defaultSource = int(defaultSource) elif fieldType in ("float", "double"): defaultSource = float(defaultSource) # TODO: other types for defaultSource # elif fieldType == "datetime": idName = str(soClass.sqlmeta.idName or 'id').upper() if field.upper() == idName: continue if fieldScale: # PRECISION refers to the total number of digits, # and SCALE refers to the number of digits # to the right of the decimal point. # Both numbers can be from 1 to 18 (SQL dialect 1: 1-15), # but SCALE mustbe less than or equal to PRECISION. if fieldScale > fieldLength: fieldScale = fieldLength colClass, kw = self.guessClass(fieldType, fieldLength, fieldCharset, fieldScale) kw['name'] = str( soClass.sqlmeta.style.dbColumnToPythonAttr(field).strip()) kw['dbName'] = str(field) kw['notNone'] = not fieldNotNullConstraint kw['default'] = defaultSource results.append(colClass(**kw)) return results def guessClass(self, t, flength, fCharset, fscale=None): """ An internal method that tries to figure out what Col subclass is appropriate given whatever introspective information is available -- both very database-specific. """ # TODO: check if negative values are allowed for fscale if t == 'smallint': # -32,768 to +32,767, 16 bits return col.IntCol, {} elif t == 'integer': # -2,147,483,648 to +2,147,483,647, 32 bits return col.IntCol, {} elif t == 'bigint': # -2^63 to 2^63-1 or # -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807, 64 bits return col.IntCol, {} elif t == 'float': # 32 bits, 3.4x10^-38 to 3.4x10^38, 7 digit precision # (7 significant decimals) return col.FloatCol, {} elif t == 'double': # 64 bits, 1.7x10^-308 to 1.7x10^308, 15 digit precision # (15 significant decimals) return col.FloatCol, {} elif t == 'numeric': # Numeric and Decimal are internally stored as smallint, # integer or bigint depending on the size. # They can handle up to 18 digits. if (not flength or not fscale): # If neither PRECISION nor SCALE are specified, # Firebird/InterBase defines the column as INTEGER # instead of NUMERIC and stores only the integer portion # of the value return col.IntCol, {} # check if negative values are allowed for fscale return col.DecimalCol, {'size': flength, 'precision': fscale} elif t == 'decimal': # Check if negative values are allowed for fscale return col.DecimalCol, {'size': flength, 'precision': fscale} elif t == 'date': # 32 bits, 1 Jan 100. to 29 Feb 32768. return col.DateCol, {} elif t == 'time': # 32 bits, 00:00 to 23:59.9999 return col.TimeCol, {} elif t == 'timestamp': # 64 bits, 1 Jan 100 to 28 Feb 32768. return col.DateTimeCol, {} elif t == 'char': # 32767 bytes if fCharset and (fCharset != "NONE"): return col.UnicodeCol, {'length': flength, 'varchar': False, 'dbEncoding': fCharset} elif self.dbEncoding: return col.UnicodeCol, {'length': flength, 'varchar': False, 'dbEncoding': self.dbEncoding} else: return col.StringCol, {'length': flength, 'varchar': False} elif t == 'varchar': # 32767 bytes if fCharset and (fCharset != "NONE"): return col.UnicodeCol, {'length': flength, 'varchar': True, 'dbEncoding': fCharset} elif self.dbEncoding: return col.UnicodeCol, {'length': flength, 'varchar': True, 'dbEncoding': self.dbEncoding} else: return col.StringCol, {'length': flength, 'varchar': True} elif t == 'blob': # 32GB return col.BLOBCol, {} else: return col.Col, {} def createEmptyDatabase(self): self.module.create_database( "CREATE DATABASE '%s' user '%s' password '%s'" % (self.db, self.user, self.password)) def dropDatabase(self): self.module.drop_database() SQLObject-3.1.0/sqlobject/sybase/0000755000175000017500000000000012754657361016145 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/sybase/__init__.py0000644000175000017500000000030012464733165020242 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import sybaseconnection return sybaseconnection.SybaseConnection registerConnection(['sybase'], builder) SQLObject-3.1.0/sqlobject/sybase/sybaseconnection.py0000644000175000017500000001344512464226747022072 0ustar phdphd00000000000000from sqlobject.dbconnection import DBAPI from sqlobject import col class SybaseConnection(DBAPI): supportTransactions = False dbName = 'sybase' schemes = [dbName] NumericType = None def __init__(self, db, user, password='', host='localhost', port=None, locking=1, **kw): db = db.strip('/') import Sybase Sybase._ctx.debug = 0 if SybaseConnection.NumericType is None: from Sybase import NumericType SybaseConnection.NumericType = NumericType from sqlobject.converters import registerConverter, IntConverter registerConverter(NumericType, IntConverter) self.module = Sybase self.locking = int(locking) self.host = host self.port = port self.db = db self.user = user self.password = password autoCommit = kw.get('autoCommit') if autoCommit: autoCommit = int(autoCommit) else: autoCommit = None kw['autoCommit'] = autoCommit DBAPI.__init__(self, **kw) @classmethod def _connectionFromParams(cls, user, password, host, port, path, args): return cls(user=user, password=password, host=host or 'localhost', port=port, db=path, **args) def insert_id(self, conn): """ Sybase adapter/cursor does not support the insert_id method. """ c = conn.cursor() c.execute('SELECT @@IDENTITY') return c.fetchone()[0] def makeConnection(self): return self.module.connect(self.host, self.user, self.password, database=self.db, auto_commit=self.autoCommit, locking=self.locking) HAS_IDENTITY = """ SELECT col.name, col.status, obj.name FROM syscolumns col JOIN sysobjects obj ON obj.id = col.id WHERE obj.name = '%s' AND (col.status & 0x80) = 0x80 """ def _hasIdentity(self, conn, table): query = self.HAS_IDENTITY % table c = conn.cursor() c.execute(query) r = c.fetchone() return r is not None def _queryInsertID(self, conn, soInstance, id, names, values): table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName c = conn.cursor() if id is not None: names = [idName] + names values = [id] + values has_identity = self._hasIdentity(conn, table) identity_insert_on = False if has_identity and (id is not None): identity_insert_on = True c.execute('SET IDENTITY_INSERT %s ON' % table) q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') c.execute(q) if has_identity and identity_insert_on: c.execute('SET IDENTITY_INSERT %s OFF' % table) if id is None: id = self.insert_id(conn) if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id @classmethod def _queryAddLimitOffset(cls, query, start, end): # XXX Sybase doesn't support OFFSET if end: return "SET ROWCOUNT %i %s SET ROWCOUNT 0" % (end, query) return query def createReferenceConstraint(self, soClass, col): return None def createColumn(self, soClass, col): return col.sybaseCreateSQL() def createIDColumn(self, soClass): key_type = {int: "NUMERIC(18,0)", str: "TEXT"}[soClass.sqlmeta.idType] return '%s %s IDENTITY UNIQUE' % (soClass.sqlmeta.idName, key_type) def createIndexSQL(self, soClass, index): return index.sybaseCreateIndexSQL(soClass) def joinSQLType(self, join): return 'NUMERIC(18,0) NOT NULL' SHOW_TABLES = "SELECT name FROM sysobjects WHERE type='U'" def tableExists(self, tableName): for (table,) in self.queryAll(self.SHOW_TABLES): if table.lower() == tableName.lower(): return True return False def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD COLUMN %s' % (tableName, column.sybaseCreateSQL())) def delColumn(self, sqlmeta, column): self.query( 'ALTER TABLE %s DROP COLUMN %s' % (sqlmeta.table, column.dbName)) SHOW_COLUMNS = ('SELECT ' 'COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT ' 'FROM INFORMATION_SCHEMA.COLUMNS ' 'WHERE TABLE_NAME = \'%s\'') def columnsFromSchema(self, tableName, soClass): colData = self.queryAll(self.SHOW_COLUMNS % tableName) results = [] for field, t, nullAllowed, default in colData: if field == soClass.sqlmeta.idName: continue colClass, kw = self.guessClass(t) kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['dbName'] = field kw['notNone'] = not nullAllowed kw['default'] = default # @@ skip key... # @@ skip extra... kw['forceDBName'] = True results.append(colClass(**kw)) return results def _setAutoCommit(self, conn, auto): conn.auto_commit = auto def guessClass(self, t): if t.startswith('int'): return col.IntCol, {} elif t.startswith('varchar'): return col.StringCol, {'length': int(t[8:-1])} elif t.startswith('char'): return col.StringCol, {'length': int(t[5:-1]), 'varchar': False} elif t.startswith('datetime'): return col.DateTimeCol, {} else: return col.Col, {} SQLObject-3.1.0/sqlobject/styles.py0000644000175000017500000001067012463427161016546 0ustar phdphd00000000000000import re __all__ = ["Style", "MixedCaseUnderscoreStyle", "DefaultStyle", "MixedCaseStyle"] class Style(object): """ The base Style class, and also the simplest implementation. No translation occurs -- column names and attribute names match, as do class names and table names (when using auto class or schema generation). """ def __init__(self, pythonAttrToDBColumn=None, dbColumnToPythonAttr=None, pythonClassToDBTable=None, dbTableToPythonClass=None, idForTable=None, longID=False): if pythonAttrToDBColumn: self.pythonAttrToDBColumn = \ lambda a, s=self: pythonAttrToDBColumn(s, a) if dbColumnToPythonAttr: self.dbColumnToPythonAttr = \ lambda a, s=self: dbColumnToPythonAttr(s, a) if pythonClassToDBTable: self.pythonClassToDBTable = \ lambda a, s=self: pythonClassToDBTable(s, a) if dbTableToPythonClass: self.dbTableToPythonClass = \ lambda a, s=self: dbTableToPythonClass(s, a) if idForTable: self.idForTable = lambda a, s=self: idForTable(s, a) self.longID = longID def pythonAttrToDBColumn(self, attr): return attr def dbColumnToPythonAttr(self, col): return col def pythonClassToDBTable(self, className): return className def dbTableToPythonClass(self, table): return table def idForTable(self, table): if self.longID: return self.tableReference(table) else: return 'id' def pythonClassToAttr(self, className): return lowerword(className) def instanceAttrToIDAttr(self, attr): return attr + "ID" def instanceIDAttrToAttr(self, attr): return attr[:-2] def tableReference(self, table): return table + "_id" class MixedCaseUnderscoreStyle(Style): """ This is the default style. Python attributes use mixedCase, while database columns use underscore_separated. """ def pythonAttrToDBColumn(self, attr): return mixedToUnder(attr) def dbColumnToPythonAttr(self, col): return underToMixed(col) def pythonClassToDBTable(self, className): return className[0].lower() \ + mixedToUnder(className[1:]) def dbTableToPythonClass(self, table): return table[0].upper() \ + underToMixed(table[1:]) def pythonClassToDBTableReference(self, className): return self.tableReference(self.pythonClassToDBTable(className)) def tableReference(self, table): return table + "_id" DefaultStyle = MixedCaseUnderscoreStyle class MixedCaseStyle(Style): """ This style leaves columns as mixed-case, and uses long ID names (like ProductID instead of simply id). """ def pythonAttrToDBColumn(self, attr): return capword(attr) def dbColumnToPythonAttr(self, col): return lowerword(col) def dbTableToPythonClass(self, table): return capword(table) def tableReference(self, table): return table + "ID" defaultStyle = DefaultStyle() def getStyle(soClass, dbConnection=None): if dbConnection is None: if hasattr(soClass, '_connection'): dbConnection = soClass._connection if hasattr(soClass.sqlmeta, 'style') and soClass.sqlmeta.style: return soClass.sqlmeta.style elif dbConnection and dbConnection.style: return dbConnection.style else: return defaultStyle ############################################################ # Text utilities ############################################################ _mixedToUnderRE = re.compile(r'[A-Z]+') def mixedToUnder(s): if s.endswith('ID'): return mixedToUnder(s[:-2] + "_id") trans = _mixedToUnderRE.sub(mixedToUnderSub, s) if trans.startswith('_'): trans = trans[1:] return trans def mixedToUnderSub(match): m = match.group(0).lower() if len(m) > 1: return '_%s_%s' % (m[:-1], m[-1]) else: return '_%s' % m def capword(s): return s[0].upper() + s[1:] def lowerword(s): return s[0].lower() + s[1:] _underToMixedRE = re.compile('_.') def underToMixed(name): if name.endswith('_id'): return underToMixed(name[:-3] + "ID") return _underToMixedRE.sub(lambda m: m.group(0)[1].upper(), name) SQLObject-3.1.0/sqlobject/sqlite/0000755000175000017500000000000012754657361016160 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/sqlite/__init__.py0000644000175000017500000000030012464733165020255 0ustar phdphd00000000000000from sqlobject.dbconnection import registerConnection def builder(): from . import sqliteconnection return sqliteconnection.SQLiteConnection registerConnection(['sqlite'], builder) SQLObject-3.1.0/sqlobject/sqlite/sqliteconnection.py0000644000175000017500000004001212470415717022100 0ustar phdphd00000000000000import base64 import os try: from _thread import get_ident except ImportError: from thread import get_ident try: from urllib import quote except ImportError: from urllib.parse import quote from sqlobject import col from sqlobject import dberrors from sqlobject.dbconnection import DBAPI, Boolean sqlite2_Binary = None class ErrorMessage(str): def __new__(cls, e): obj = str.__new__(cls, e.args[0]) obj.code = None obj.module = e.__module__ obj.exception = e.__class__.__name__ return obj class SQLiteConnection(DBAPI): supportTransactions = True dbName = 'sqlite' schemes = [dbName] def __init__(self, filename, autoCommit=1, **kw): drivers = kw.pop('driver', None) or 'pysqlite2,sqlite3,sqlite' for driver in drivers.split(','): driver = driver.strip() if not driver: continue try: if driver in ('sqlite2', 'pysqlite2'): from pysqlite2 import dbapi2 as sqlite self.using_sqlite2 = True elif driver == 'sqlite3': import sqlite3 as sqlite self.using_sqlite2 = True elif driver in ('sqlite', 'sqlite1'): import sqlite self.using_sqlite2 = False else: raise ValueError( 'Unknown SQLite driver "%s", ' 'expected pysqlite2, sqlite3 or sqlite' % driver) except ImportError: pass else: break else: raise ImportError( 'Cannot find an SQLite driver, tried %s' % drivers) if self.using_sqlite2: sqlite.encode = base64.encodestring sqlite.decode = base64.decodestring self.module = sqlite self.filename = filename # full path to sqlite-db-file self._memory = filename == ':memory:' if self._memory and not self.using_sqlite2: raise ValueError("You must use sqlite2 to use in-memory databases") # connection options opts = {} if self.using_sqlite2: if autoCommit: opts["isolation_level"] = None global sqlite2_Binary if sqlite2_Binary is None: sqlite2_Binary = sqlite.Binary sqlite.Binary = lambda s: sqlite2_Binary(sqlite.encode(s)) if 'factory' in kw: factory = kw.pop('factory') if isinstance(factory, str): factory = globals()[factory] opts['factory'] = factory(sqlite) else: opts['autocommit'] = Boolean(autoCommit) if 'encoding' in kw: opts['encoding'] = kw.pop('encoding') if 'mode' in kw: opts['mode'] = int(kw.pop('mode'), 0) if 'timeout' in kw: if self.using_sqlite2: opts['timeout'] = float(kw.pop('timeout')) else: opts['timeout'] = int(float(kw.pop('timeout')) * 1000) if 'check_same_thread' in kw: opts["check_same_thread"] = Boolean(kw.pop('check_same_thread')) # use only one connection for sqlite - supports multiple) # cursors per connection self._connOptions = opts self.use_table_info = Boolean(kw.pop("use_table_info", True)) DBAPI.__init__(self, **kw) self._threadPool = {} self._threadOrigination = {} if self._memory: self.makeMemoryConnection() @classmethod def _connectionFromParams(cls, user, password, host, port, path, args): assert host is None and port is None, ( "SQLite can only be used locally (with a URI like " "sqlite:/file or sqlite:///file, not sqlite://%s%s)" % (host, port and ':%r' % port or '')) assert user is None and password is None, ( "You may not provide usernames or passwords for SQLite " "databases") if path == "/:memory:": path = ":memory:" return cls(filename=path, **args) def oldUri(self): path = self.filename if path == ":memory:": path = "/:memory:" else: path = "//" + path return 'sqlite:%s' % path def uri(self): path = self.filename if path == ":memory:": path = "/:memory:" else: if path.startswith('/'): path = "//" + path else: path = "///" + path path = quote(path) return 'sqlite:%s' % path def getConnection(self): # SQLite can't share connections between threads, and so can't # pool connections. Since we are isolating threads here, we # don't have to worry about locking as much. if self._memory: conn = self.makeConnection() self._connectionNumbers[id(conn)] = self._connectionCount self._connectionCount += 1 return conn threadid = get_ident() if (self._pool is not None and threadid in self._threadPool): conn = self._threadPool[threadid] del self._threadPool[threadid] if conn in self._pool: self._pool.remove(conn) else: conn = self.makeConnection() if self._pool is not None: self._threadOrigination[id(conn)] = threadid self._connectionNumbers[id(conn)] = self._connectionCount self._connectionCount += 1 if self.debug: s = 'ACQUIRE' if self._pool is not None: s += ' pool=[%s]' % ', '.join( [str(self._connectionNumbers[id(v)]) for v in self._pool]) self.printDebug(conn, s, 'Pool') return conn def releaseConnection(self, conn, explicit=False): if self._memory: return threadid = self._threadOrigination.get(id(conn)) DBAPI.releaseConnection(self, conn, explicit=explicit) if (self._pool is not None and threadid and threadid not in self._threadPool): self._threadPool[threadid] = conn else: if self._pool and conn in self._pool: self._pool.remove(conn) conn.close() def _setAutoCommit(self, conn, auto): if self.using_sqlite2: if auto: conn.isolation_level = None else: conn.isolation_level = "" else: conn.autocommit = auto def _setIsolationLevel(self, conn, level): if not self.using_sqlite2: return conn.isolation_level = level def makeMemoryConnection(self): self._memoryConn = self.module.connect( self.filename, **self._connOptions) # Convert text data from SQLite to str, not unicode - # SQLObject converts it to unicode itself. self._memoryConn.text_factory = str def makeConnection(self): if self._memory: return self._memoryConn conn = self.module.connect(self.filename, **self._connOptions) conn.text_factory = str # Convert text data to str, not unicode return conn def close(self): DBAPI.close(self) self._threadPool = {} if self._memory: self._memoryConn.close() self.makeMemoryConnection() def _executeRetry(self, conn, cursor, query): if self.debug: self.printDebug(conn, query, 'QueryR') try: return cursor.execute(query) except self.module.OperationalError as e: raise dberrors.OperationalError(ErrorMessage(e)) except self.module.IntegrityError as e: msg = ErrorMessage(e) if msg.startswith('column') and msg.endswith('not unique') \ or msg.startswith('UNIQUE constraint failed:'): raise dberrors.DuplicateEntryError(msg) else: raise dberrors.IntegrityError(msg) except self.module.InternalError as e: raise dberrors.InternalError(ErrorMessage(e)) except self.module.ProgrammingError as e: raise dberrors.ProgrammingError(ErrorMessage(e)) except self.module.DataError as e: raise dberrors.DataError(ErrorMessage(e)) except self.module.NotSupportedError as e: raise dberrors.NotSupportedError(ErrorMessage(e)) except self.module.DatabaseError as e: raise dberrors.DatabaseError(ErrorMessage(e)) except self.module.InterfaceError as e: raise dberrors.InterfaceError(ErrorMessage(e)) except self.module.Warning as e: raise Warning(ErrorMessage(e)) except self.module.Error as e: raise dberrors.Error(ErrorMessage(e)) def _queryInsertID(self, conn, soInstance, id, names, values): table = soInstance.sqlmeta.table idName = soInstance.sqlmeta.idName c = conn.cursor() if id is not None: names = [idName] + names values = [id] + values q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') self._executeRetry(conn, c, q) # lastrowid is a DB-API extension from "PEP 0249": if id is None: id = int(c.lastrowid) if self.debugOutput: self.printDebug(conn, id, 'QueryIns', 'result') return id def _insertSQL(self, table, names, values): if not names: assert not values # INSERT INTO table () VALUES () isn't allowed in # SQLite (though it is in other databases) return ("INSERT INTO %s VALUES (NULL)" % table) else: return DBAPI._insertSQL(self, table, names, values) @classmethod def _queryAddLimitOffset(cls, query, start, end): if not start: return "%s LIMIT %i" % (query, end) if not end: return "%s LIMIT 0 OFFSET %i" % (query, start) return "%s LIMIT %i OFFSET %i" % (query, end - start, start) def createColumn(self, soClass, col): return col.sqliteCreateSQL() def createReferenceConstraint(self, soClass, col): return None def createIDColumn(self, soClass): return self._createIDColumn(soClass.sqlmeta) def _createIDColumn(self, sqlmeta): if sqlmeta.idType == str: return '%s TEXT PRIMARY KEY' % sqlmeta.idName return '%s INTEGER PRIMARY KEY AUTOINCREMENT' % sqlmeta.idName def joinSQLType(self, join): return 'INT NOT NULL' def tableExists(self, tableName): result = self.queryOne( "SELECT tbl_name FROM sqlite_master " "WHERE type='table' AND tbl_name = '%s'" % tableName) # turn it into a boolean: return not not result def createIndexSQL(self, soClass, index): return index.sqliteCreateIndexSQL(soClass) def addColumn(self, tableName, column): self.query('ALTER TABLE %s ADD COLUMN %s' % (tableName, column.sqliteCreateSQL())) self.query('VACUUM %s' % tableName) def delColumn(self, sqlmeta, column): self.recreateTableWithoutColumn(sqlmeta, column) def recreateTableWithoutColumn(self, sqlmeta, column): new_name = sqlmeta.table + '_ORIGINAL' self.query('ALTER TABLE %s RENAME TO %s' % (sqlmeta.table, new_name)) cols = [self._createIDColumn(sqlmeta)] + \ [self.createColumn(None, col) for col in sqlmeta.columnList if col.name != column.name] cols = ",\n".join([" %s" % c for c in cols]) self.query('CREATE TABLE %s (\n%s\n)' % (sqlmeta.table, cols)) all_columns = ', '.join( [sqlmeta.idName] + [col.dbName for col in sqlmeta.columnList]) self.query('INSERT INTO %s (%s) SELECT %s FROM %s' % ( sqlmeta.table, all_columns, all_columns, new_name)) self.query('DROP TABLE %s' % new_name) def columnsFromSchema(self, tableName, soClass): if self.use_table_info: return self._columnsFromSchemaTableInfo(tableName, soClass) else: return self._columnsFromSchemaParse(tableName, soClass) def _columnsFromSchemaTableInfo(self, tableName, soClass): colData = self.queryAll("PRAGMA table_info(%s)" % tableName) results = [] for index, field, t, nullAllowed, default, key in colData: if field == soClass.sqlmeta.idName: continue colClass, kw = self.guessClass(t) if default == 'NULL': nullAllowed = True default = None kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['dbName'] = field kw['notNone'] = not nullAllowed kw['default'] = default # @@ skip key... # @@ skip extra... results.append(colClass(**kw)) return results def _columnsFromSchemaParse(self, tableName, soClass): colData = self.queryOne( "SELECT sql FROM sqlite_master WHERE type='table' AND name='%s'" % tableName) if not colData: raise ValueError( 'The table %s was not found in the database. Load failed.' % tableName) colData = colData[0].split('(', 1)[1].strip()[:-2] while True: start = colData.find('(') if start == -1: break end = colData.find(')', start) if end == -1: break colData = colData[:start] + colData[end + 1:] results = [] for colDesc in colData.split(','): parts = colDesc.strip().split(' ', 2) field = parts[0].strip() # skip comments if field.startswith('--'): continue # get rid of enclosing quotes if field[0] == field[-1] == '"': field = field[1:-1] if field == getattr(soClass.sqlmeta, 'idName', 'id'): continue colClass, kw = self.guessClass(parts[1].strip()) if len(parts) == 2: index_info = '' else: index_info = parts[2].strip().upper() kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['dbName'] = field import re nullble = re.search(r'(\b\S*)\sNULL', index_info) default = re.search( r"DEFAULT\s((?:\d[\dA-FX.]*)|(?:'[^']*')|(?:#[^#]*#))", index_info) kw['notNone'] = nullble and nullble.group(1) == 'NOT' kw['default'] = default and default.group(1) # @@ skip key... # @@ skip extra... results.append(colClass(**kw)) return results def guessClass(self, t): t = t.upper() if t.find('INT') >= 0: return col.IntCol, {} elif t.find('TEXT') >= 0 or t.find('CHAR') >= 0 or t.find('CLOB') >= 0: return col.StringCol, {'length': 2 ** 32 - 1} elif t.find('BLOB') >= 0: return col.BLOBCol, {"length": 2 ** 32 - 1} elif t.find('REAL') >= 0 or t.find('FLOAT') >= 0: return col.FloatCol, {} elif t.find('DECIMAL') >= 0: return col.DecimalCol, {'size': None, 'precision': None} elif t.find('BOOL') >= 0: return col.BoolCol, {} else: return col.Col, {} def listTables(self): return [v[0] for v in self.queryAll( "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")] def listDatabases(self): # The pragma returns a list of (index, name, filename) return [v[1] for v in self.queryAll("PRAGMA database_list")] def createEmptyDatabase(self): if self._memory: return open(self.filename, 'w').close() def dropDatabase(self): if self._memory: return os.unlink(self.filename) SQLObject-3.1.0/sqlobject/constraints.py0000644000175000017500000000367112503207731017567 0ustar phdphd00000000000000""" Constraints """ from sqlobject.compat import PY2 if not PY2: # alias for python 3 compatability long = int class BadValue(ValueError): def __init__(self, desc, obj, col, value, *args): self.desc = desc self.col = col # I want these objects to be garbage-collectable, so # I just keep their repr: self.obj = repr(obj) self.value = repr(value) fullDesc = "%s.%s %s (you gave: %s)" \ % (obj, col.name, desc, value) ValueError.__init__(self, fullDesc, *args) def isString(obj, col, value): if not isinstance(value, str): raise BadValue("only allows strings", obj, col, value) def notNull(obj, col, value): if value is None: raise BadValue("is defined NOT NULL", obj, col, value) def isInt(obj, col, value): if not isinstance(value, (int, long)): raise BadValue("only allows integers", obj, col, value) def isFloat(obj, col, value): if not isinstance(value, (int, long, float)): raise BadValue("only allows floating point numbers", obj, col, value) def isBool(obj, col, value): if not isinstance(value, bool): raise BadValue("only allows booleans", obj, col, value) class InList: def __init__(self, l): self.list = l def __call__(self, obj, col, value): if value not in self.list: raise BadValue("accepts only values in %s" % repr(self.list), obj, col, value) class MaxLength: def __init__(self, length): self.length = length def __call__(self, obj, col, value): try: length = len(value) except TypeError: raise BadValue("object does not have a length", obj, col, value) if length > self.length: raise BadValue("must be shorter in length than %s" % self.length, obj, col, value) SQLObject-3.1.0/sqlobject/dberrors.py0000644000175000017500000000135212747416061017044 0ustar phdphd00000000000000"""dberrors: database exception classes for SQLObject. These classes are dictated by the DB API v2.0, see: https://wiki.python.org/moin/DatabaseProgramming """ from sqlobject.compat import PY2 if not PY2: StandardError = Exception class Error(StandardError): pass class Warning(StandardError): pass class InterfaceError(Error): pass class DatabaseError(Error): pass class InternalError(DatabaseError): pass class OperationalError(DatabaseError): pass class ProgrammingError(DatabaseError): pass class IntegrityError(DatabaseError): pass class DataError(DatabaseError): pass class NotSupportedError(DatabaseError): pass class DuplicateEntryError(IntegrityError): pass SQLObject-3.1.0/sqlobject/events.py0000644000175000017500000002772512471401471016533 0ustar phdphd00000000000000from __future__ import print_function import sys import types from pydispatch import dispatcher from weakref import ref from .compat import class_types subclassClones = {} def listen(receiver, soClass, signal, alsoSubclasses=True, weak=True): """ Listen for the given ``signal`` on the SQLObject subclass ``soClass``, calling ``receiver()`` when ``send(soClass, signal, ...)`` is called. If ``alsoSubclasses`` is true, receiver will also be called when an event is fired on any subclass. """ dispatcher.connect(receiver, signal=signal, sender=soClass, weak=weak) weakReceiver = ref(receiver) subclassClones.setdefault(soClass, []).append((weakReceiver, signal)) # We export this function: send = dispatcher.send class Signal(object): """ Base event for all SQLObject events. In general the sender for these methods is the class, not the instance. """ class ClassCreateSignal(Signal): """ Signal raised after class creation. The sender is the superclass (in case of multiple superclasses, the first superclass). The arguments are ``(new_class_name, bases, new_attrs, post_funcs, early_funcs)``. ``new_attrs`` is a dictionary and may be modified (but ``new_class_name`` and ``bases`` are immutable). ``post_funcs`` is an initially-empty list that can have callbacks appended to it. Note: at the time this event is called, the new class has not yet been created. The functions in ``post_funcs`` will be called after the class is created, with the single arguments of ``(new_class)``. Also, ``early_funcs`` will be called at the soonest possible time after class creation (``post_funcs`` is called after the class's ``__classinit__``). """ def _makeSubclassConnections(new_class_name, bases, new_attrs, post_funcs, early_funcs): early_funcs.insert(0, _makeSubclassConnectionsPost) def _makeSubclassConnectionsPost(new_class): for cls in new_class.__bases__: for weakReceiver, signal in subclassClones.get(cls, []): receiver = weakReceiver() if not receiver: continue listen(receiver, new_class, signal) dispatcher.connect(_makeSubclassConnections, signal=ClassCreateSignal) # @@: Should there be a class reload event? This would allow modules # to be reloaded, possibly. Or it could even be folded into # ClassCreateSignal, since anything that listens to that needs to pay # attention to reloads (or else it is probably buggy). class RowCreateSignal(Signal): """ Called before an instance is created, with the class as the sender. Called with the arguments ``(instance, kwargs, post_funcs)``. There may be a ``connection`` argument. ``kwargs``may be usefully modified. ``post_funcs`` is a list of callbacks, intended to have functions appended to it, and are called with the arguments ``(new_instance)``. Note: this is not called when an instance is created from an existing database row. """ class RowCreatedSignal(Signal): """ Called after an instance is created, with the class as the sender. Called with the arguments ``(instance, kwargs, post_funcs)``. There may be a ``connection`` argument. ``kwargs``may be usefully modified. ``post_funcs`` is a list of callbacks, intended to have functions appended to it, and are called with the arguments ``(new_instance)``. Note: this is not called when an instance is created from an existing database row. """ # @@: An event for getting a row? But for each row, when doing a # select? For .sync, .syncUpdate, .expire? class RowDestroySignal(Signal): """ Called before an instance is deleted. Sender is the instance's class. Arguments are ``(instance, post_funcs)``. ``post_funcs`` is a list of callbacks, intended to have functions appended to it, and are called with arguments ``(instance)``. If any of the post_funcs raises an exception, the deletion is only affected if this will prevent a commit. You cannot cancel the delete, but you can raise an exception (which will probably cancel the delete, but also cause an uncaught exception if not expected). Note: this is not called when an instance is destroyed through garbage collection. @@: Should this allow ``instance`` to be a primary key, so that a row can be deleted without first fetching it? """ class RowDestroyedSignal(Signal): """ Called after an instance is deleted. Sender is the instance's class. Arguments are ``(instance)``. This is called before the post_funcs of RowDestroySignal Note: this is not called when an instance is destroyed through garbage collection. """ class RowUpdateSignal(Signal): """ Called when an instance is updated through a call to ``.set()`` (or a column attribute assignment). The arguments are ``(instance, kwargs)``. ``kwargs`` can be modified. This is run *before* the instance is updated; if you want to look at the current values, simply look at ``instance``. """ class RowUpdatedSignal(Signal): """ Called when an instance is updated through a call to ``.set()`` (or a column attribute assignment). The arguments are ``(instance, post_funcs)``. ``post_funcs`` is a list of callbacks, intended to have functions appended to it, and are called with the arguments ``(new_instance)``. This is run *after* the instance is updated; Works better with lazyUpdate = True. """ class AddColumnSignal(Signal): """ Called when a column is added to a class, with arguments ``(cls, connection, column_name, column_definition, changeSchema, post_funcs)``. This is called *after* the column has been added, and is called for each column after class creation. post_funcs are called with ``(cls, so_column_obj)`` """ class DeleteColumnSignal(Signal): """ Called when a column is removed from a class, with the arguments ``(cls, connection, column_name, so_column_obj, post_funcs)``. Like ``AddColumnSignal`` this is called after the action has been performed, and is called for subclassing (when a column is implicitly removed by setting it to ``None``). post_funcs are called with ``(cls, so_column_obj)`` """ # @@: Signals for indexes and joins? These are mostly event consumers, # though. class CreateTableSignal(Signal): """ Called when a table is created. If ``ifNotExists==True`` and the table exists, this event is not called. Called with ``(cls, connection, extra_sql, post_funcs)``. ``extra_sql`` is a list (which can be appended to) of extra SQL statements to be run after the table is created. ``post_funcs`` functions are called with ``(cls, connection)`` after the table has been created. Those functions are *not* called simply when constructing the SQL. """ class DropTableSignal(Signal): """ Called when a table is dropped. If ``ifExists==True`` and the table doesn't exist, this event is not called. Called with ``(cls, connection, extra_sql, post_funcs)``. ``post_funcs`` functions are called with ``(cls, connection)`` after the table has been dropped. """ ############################################################ # Event Debugging ############################################################ def summarize_events_by_sender(sender=None, output=None, indent=0): """ Prints out a summary of the senders and listeners in the system, for debugging purposes. """ if output is None: output = sys.stdout leader = ' ' * indent if sender is None: send_list = [ (deref(dispatcher.senders.get(sid)), listeners) for sid, listeners in dispatcher.connections.items() if deref(dispatcher.senders.get(sid))] for sender, listeners in sorted_items(send_list): real_sender = deref(sender) if not real_sender: continue header = 'Sender: %r' % real_sender print(leader + header, file=output) print(leader + ('=' * len(header)), file=output) summarize_events_by_sender(real_sender, output=output, indent=indent + 2) else: for signal, receivers in \ sorted_items(dispatcher.connections.get(id(sender), [])): receivers = [deref(r) for r in receivers if deref(r)] header = 'Signal: %s (%i receivers)' % (sort_name(signal), len(receivers)) print(leader + header, file=output) print(leader + ('-' * len(header)), file=output) for receiver in sorted(receivers, key=sort_name): print(leader + ' ' + nice_repr(receiver), file=output) def deref(value): if isinstance(value, dispatcher.WEAKREF_TYPES): return value() else: return value def sorted_items(a_dict): if isinstance(a_dict, dict): a_dict = a_dict.items() return sorted(a_dict, key=lambda t: sort_name(t[0])) def sort_name(value): if isinstance(value, type): return value.__name__ elif isinstance(value, types.FunctionType): return value.__name__ else: return str(value) _real_dispatcher_send = dispatcher.send _real_dispatcher_sendExact = dispatcher.sendExact _real_dispatcher_connect = dispatcher.connect _real_dispatcher_disconnect = dispatcher.disconnect _debug_enabled = False def debug_events(): global _debug_enabled, send if _debug_enabled: return _debug_enabled = True dispatcher.send = send = _debug_send dispatcher.sendExact = _debug_sendExact dispatcher.disconnect = _debug_disconnect dispatcher.connect = _debug_connect def _debug_send(signal=dispatcher.Any, sender=dispatcher.Anonymous, *arguments, **named): print("send %s from %s: %s" % ( nice_repr(signal), nice_repr(sender), fmt_args(*arguments, **named))) return _real_dispatcher_send(signal, sender, *arguments, **named) def _debug_sendExact(signal=dispatcher.Any, sender=dispatcher.Anonymous, *arguments, **named): print("sendExact %s from %s: %s" % ( nice_repr(signal), nice_repr(sender), fmt_args(*arguments, **name))) return _real_dispatcher_sendExact(signal, sender, *arguments, **named) def _debug_connect(receiver, signal=dispatcher.Any, sender=dispatcher.Any, weak=True): print("connect %s to %s signal %s" % ( nice_repr(receiver), nice_repr(signal), nice_repr(sender))) return _real_dispatcher_connect(receiver, signal, sender, weak) def _debug_disconnect(receiver, signal=dispatcher.Any, sender=dispatcher.Any, weak=True): print("disconnecting %s from %s signal %s" % ( nice_repr(receiver), nice_repr(signal), nice_repr(sender))) return _real_dispatcher_disconnect(receiver, signal, sender, weak) def fmt_args(*arguments, **name): args = [repr(a) for a in arguments] args.extend([ '%s=%r' % (n, v) for n, v in sorted(name.items())]) return ', '.join(args) def nice_repr(v): """ Like repr(), but nicer for debugging here. """ if isinstance(v, class_types): return v.__module__ + '.' + v.__name__ elif isinstance(v, types.FunctionType): if '__name__' in v.__globals__: if getattr(sys.modules[v.__globals__['__name__']], v.__name__, None) is v: return '%s.%s' % (v.__globals__['__name__'], v.__name__) return repr(v) elif isinstance(v, types.MethodType): return '%s.%s of %s' % ( nice_repr(v.__self__.__class__), v.__func__.__name__, nice_repr(v.__self__)) else: return repr(v) __all__ = ['listen', 'send'] # Use copy() to avoid 'dictionary changed' issues on python 3 for name, value in globals().copy().items(): if isinstance(value, type) and issubclass(value, Signal): __all__.append(name) SQLObject-3.1.0/sqlobject/views.py0000644000175000017500000001336112747416060016361 0ustar phdphd00000000000000from .main import SQLObject from .sqlbuilder import AND, Alias, ColumnAS, LEFTJOINOn, \ NoDefault, SQLCall, SQLConstant, SQLObjectField, SQLObjectTable, SQLOp, \ Select, sqlrepr class ViewSQLObjectField(SQLObjectField): def __init__(self, alias, *arg): SQLObjectField.__init__(self, *arg) self.alias = alias def __sqlrepr__(self, db): return self.alias + "." + self.fieldName def tablesUsedImmediate(self): return [self.tableName] class ViewSQLObjectTable(SQLObjectTable): FieldClass = ViewSQLObjectField def __getattr__(self, attr): if attr == 'sqlmeta': raise AttributeError return SQLObjectTable.__getattr__(self, attr) def _getattrFromID(self, attr): return self.FieldClass(self.soClass.sqlmeta.alias, self.tableName, 'id', attr, self.soClass, None) def _getattrFromColumn(self, column, attr): return self.FieldClass(self.soClass.sqlmeta.alias, self.tableName, column.name, attr, self.soClass, column) class ViewSQLObject(SQLObject): """ A SQLObject class that derives all it's values from other SQLObject classes. Columns on subclasses should use SQLBuilder constructs for dbName, and sqlmeta should specify: * idName as a SQLBuilder construction * clause as SQLBuilder clause for specifying join conditions or other restrictions * table as an optional alternate name for the class alias See test_views.py for simple examples. """ def __classinit__(cls, new_attrs): SQLObject.__classinit__(cls, new_attrs) # like is_base if cls.__name__ != 'ViewSQLObject': dbName = hasattr(cls, '_connection') and \ (cls._connection and cls._connection.dbName) or None if getattr(cls.sqlmeta, 'table', None): cls.sqlmeta.alias = cls.sqlmeta.table else: cls.sqlmeta.alias = \ cls.sqlmeta.style.pythonClassToDBTable(cls.__name__) alias = cls.sqlmeta.alias columns = [ColumnAS(cls.sqlmeta.idName, 'id')] # {sqlrepr-key: [restriction, *aggregate-column]} aggregates = {'': [None]} inverseColumns = dict( [(y, x) for x, y in cls.sqlmeta.columns.items()]) for col in cls.sqlmeta.columnList: n = inverseColumns[col] ascol = ColumnAS(col.dbName, n) if isAggregate(col.dbName): restriction = getattr(col, 'aggregateClause', None) if restriction: restrictkey = sqlrepr(restriction, dbName) aggregates[restrictkey] = \ aggregates.get(restrictkey, [restriction]) + \ [ascol] else: aggregates[''].append(ascol) else: columns.append(ascol) metajoin = getattr(cls.sqlmeta, 'join', NoDefault) clause = getattr(cls.sqlmeta, 'clause', NoDefault) select = Select(columns, distinct=True, # @@ LDO check if this really mattered # for performance # @@ Postgres (and MySQL?) extension! # distinctOn=cls.sqlmeta.idName, join=metajoin, clause=clause) aggregates = aggregates.values() if aggregates != [[None]]: join = [] last_alias = "%s_base" % alias last_id = "id" last = Alias(select, last_alias) columns = [ ColumnAS(SQLConstant("%s.%s" % (last_alias, x.expr2)), x.expr2) for x in columns] for i, agg in enumerate(aggregates): restriction = agg[0] if restriction is None: restriction = clause else: restriction = AND(clause, restriction) agg = agg[1:] agg_alias = "%s_%s" % (alias, i) agg_id = '%s_id' % agg_alias if not last.q.alias.endswith('base'): last = None new_alias = Alias(Select( [ColumnAS(cls.sqlmeta.idName, agg_id)] + agg, groupBy=cls.sqlmeta.idName, join=metajoin, clause=restriction), agg_alias) agg_join = LEFTJOINOn(last, new_alias, "%s.%s = %s.%s" % ( last_alias, last_id, agg_alias, agg_id)) join.append(agg_join) for col in agg: columns.append( ColumnAS(SQLConstant( "%s.%s" % (agg_alias, col.expr2)), col.expr2)) last = new_alias last_alias = agg_alias last_id = agg_id select = Select(columns, join=join) cls.sqlmeta.table = Alias(select, alias) cls.q = ViewSQLObjectTable(cls) for n, col in cls.sqlmeta.columns.items(): col.dbName = n def isAggregate(expr): if isinstance(expr, SQLCall): return True if isinstance(expr, SQLOp): return isAggregate(expr.expr1) or isAggregate(expr.expr2) return False SQLObject-3.1.0/sqlobject/include/0000755000175000017500000000000012754657361016302 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/include/__init__.py0000644000175000017500000000000210332042146020356 0ustar phdphd00000000000000# SQLObject-3.1.0/sqlobject/include/hashcol.py0000644000175000017500000000615312640254342020264 0ustar phdphd00000000000000import sqlobject.col from sqlobject.compat import PY2, string_type __all__ = ['HashCol'] class DbHash: """ Presents a comparison object for hashes, allowing plain text to be automagically compared with the base content. """ def __init__(self, hash, hashMethod): self.hash = hash self.hashMethod = hashMethod def _get_key(self, other): """Create the hash of the other class""" if not isinstance(other, string_type): raise TypeError( "A hash may only be compared with a string, or None.") return self.hashMethod(other) def __eq__(self, other): if other is None: if self.hash is None: return True return False other_key = self._get_key(other) return other_key == self.hash def __lt__(self, other): if other is None: return False other_key = self._get_key(other) return other_key < self.hash def __gt__(self, other): if other is None: if self.hash is None: return False return True other_key = self._get_key(other) return other_key > self.hash def __le__(self, other): if other is None: if self.hash is None: return True return False other_key = self._get_key(other) return other_key <= self.hash def __ge__(self, other): if other is None: return True other_key = self._get_key(other) return other_key >= self.hash def __repr__(self): return "" class HashValidator(sqlobject.col.StringValidator): """ Provides formal SQLObject validation services for the HashCol. """ def to_python(self, value, state): """ Passes out a hash object. """ if value is None: return None return DbHash(hash=value, hashMethod=self.hashMethod) def from_python(self, value, state): """ Store the given value as a MD5 hash, or None if specified. """ if value is None: return None return self.hashMethod(value) class SOHashCol(sqlobject.col.SOStringCol): """ The internal HashCol definition. By default, enforces a md5 digest. """ def __init__(self, **kw): if 'hashMethod' not in kw: from hashlib import md5 if PY2: self.hashMethod = lambda v: md5(v).hexdigest() else: self.hashMethod = lambda v: md5(v.encode('utf8')).hexdigest() if 'length' not in kw: kw['length'] = 32 else: self.hashMethod = kw['hashMethod'] del kw['hashMethod'] super(SOHashCol, self).__init__(**kw) def createValidators(self): return [HashValidator(name=self.name, hashMethod=self.hashMethod)] + \ super(SOHashCol, self).createValidators() class HashCol(sqlobject.col.StringCol): """ End-user HashCol class. May be instantiated with 'hashMethod', a function which returns the string hash of any other string (i.e. basestring). """ baseClass = SOHashCol SQLObject-3.1.0/sqlobject/include/tests/0000755000175000017500000000000012754657361017444 5ustar phdphd00000000000000SQLObject-3.1.0/sqlobject/include/tests/__init__.py0000644000175000017500000000000212473702601021527 0ustar phdphd00000000000000# SQLObject-3.1.0/sqlobject/include/tests/test_hashcol.py0000644000175000017500000000435512747416060022474 0ustar phdphd00000000000000from hashlib import sha256, md5 from sqlobject import AND, IntCol, OR, SQLObject from sqlobject.compat import PY2 from sqlobject.include import hashcol from sqlobject.tests.dbtest import setupClass ######################################## # HashCol test ######################################## if PY2: def sha256_str(x): return sha256(x).hexdigest() def md5_str(x): return md5(x).hexdigest() else: def sha256_str(x): return sha256(x.encode('utf8')).hexdigest() def md5_str(x): return md5(x.encode('utf8')).hexdigest() class HashTest(SQLObject): count = IntCol(alternateID=True) col1 = hashcol.HashCol() col2 = hashcol.HashCol(hashMethod=sha256_str) data = ['test', 'This is more text', 'test 2'] items = [] def setup(): global items items = [] setupClass(HashTest) for i, s in enumerate(data): items.append(HashTest(count=i, col1=s, col2=s)) def test_create(): setup() for s, item in zip(data, items): assert item.col1 == s assert item.col2 == s conn = HashTest._connection rows = conn.queryAll(""" SELECT count, col1, col2 FROM hash_test ORDER BY count """) for count, col1, col2 in rows: assert md5_str(data[count]) == col1 assert sha256_str(data[count]) == col2 def test_select(): for i, value in enumerate(data): rows = list(HashTest.select(HashTest.q.col1 == value)) assert len(rows) == 1 rows = list(HashTest.select(HashTest.q.col2 == value)) assert len(rows) == 1 # Passing the hash in directly should fail rows = list(HashTest.select(HashTest.q.col2 == sha256_str(value))) assert len(rows) == 0 rows = list(HashTest.select(AND( HashTest.q.col1 == value, HashTest.q.col2 == value ))) assert len(rows) == 1 rows = list(HashTest.selectBy(col1=value)) assert len(rows) == 1 rows = list(HashTest.selectBy(col2=value)) assert len(rows) == 1 rows = list(HashTest.selectBy(col1=value, col2=value)) assert len(rows) == 1 rows = list(HashTest.select(OR( HashTest.q.col1 == 'test 2', HashTest.q.col2 == 'test' ))) assert len(rows) == 2 SQLObject-3.1.0/sqlobject/wsgi_middleware.py0000644000175000017500000000673712753526731020407 0ustar phdphd00000000000000import sys import sqlobject from sqlobject.compat import string_type # The module was imported during documentation building if 'pudge' not in sys.modules: from paste.deploy.converters import asbool from paste.wsgilib import catch_errors from paste.util import import_string def make_middleware(app, global_conf, database=None, use_transaction=False, hub=None): """ WSGI middleware that sets the connection for the request (using the database URI or connection object) and the given hub (or ``sqlobject.sqlhub`` if not given). If ``use_transaction`` is true, then the request will be run in a transaction. Applications can use the keys (which are all no-argument functions): ``sqlobject.get_connection()``: Returns the connection object ``sqlobject.abort()``: Aborts the transaction. Does not raise an error, but at the *end* of the request there will be a rollback. ``sqlobject.begin()``: Starts a transaction. First commits (or rolls back if aborted) if this is run in a transaction. ``sqlobject.in_transaction()``: Returns true or false, depending if we are currently in a transaction. """ use_transaction = asbool(use_transaction) if database is None: database = global_conf.get('database') if not database: raise ValueError( "You must provide a 'database' configuration value") if isinstance(hub, string_type): hub = import_string.eval_import(hub) if not hub: hub = sqlobject.sqlhub if isinstance(database, string_type): database = sqlobject.connectionForURI(database) return SQLObjectMiddleware(app, database, use_transaction, hub) class SQLObjectMiddleware(object): def __init__(self, app, conn, use_transaction, hub): self.app = app self.conn = conn self.use_transaction = use_transaction self.hub = hub def __call__(self, environ, start_response): conn = [self.conn] if self.use_transaction: conn[0] = conn[0].transaction() any_errors = [] use_transaction = [self.use_transaction] self.hub.threadConnection = conn[0] def abort(): assert use_transaction[0], ( "You cannot abort, because a transaction is not being used") any_errors.append(None) def begin(): if use_transaction[0]: if any_errors: conn[0].rollback() else: conn[0].commit() any_errors[:] = [] use_transaction[0] = True conn[0] = self.conn.transaction() self.hub.threadConnection = conn[0] def error(exc_info=None): any_errors.append(None) ok() def ok(): if use_transaction[0]: if any_errors: conn[0].rollback() else: conn[0].commit(close=True) self.hub.threadConnection = None def in_transaction(): return use_transaction[0] def get_connection(): return conn[0] environ['sqlobject.get_connection'] = get_connection environ['sqlobject.abort'] = abort environ['sqlobject.begin'] = begin environ['sqlobject.in_transaction'] = in_transaction return catch_errors(self.app, environ, start_response, error_callback=error, ok_callback=ok) SQLObject-3.1.0/sqlobject/sqlbuilder.py0000644000175000017500000013433712753527207017404 0ustar phdphd00000000000000""" sqlobject.sqlbuilder -------------------- :author: Ian Bicking Builds SQL expressions from normal Python expressions. Disclaimer ---------- This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. Instructions ------------ To begin a SQL expression, you must use some sort of SQL object -- a field, table, or SQL statement (``SELECT``, ``INSERT``, etc.) You can then use normal operators, with the exception of: `and`, `or`, `not`, and `in`. You can use the `AND`, `OR`, `NOT`, and `IN` functions instead, or you can also use `&`, `|`, and `~` for `and`, `or`, and `not` respectively (however -- the precidence for these operators doesn't work as you would want, so you must use many parenthesis). To create a sql field, table, or constant/function, use the namespaces `table`, `const`, and `func`. For instance, ``table.address`` refers to the ``address`` table, and ``table.address.state`` refers to the ``state`` field in the address table. ``const.NULL`` is the ``NULL`` SQL constant, and ``func.NOW()`` is the ``NOW()`` function call (`const` and `func` are actually identicle, but the two names are provided for clarity). Once you create this object, expressions formed with it will produce SQL statements. The ``sqlrepr(obj)`` function gets the SQL representation of these objects, as well as the proper SQL representation of basic Python types (None==NULL). There are a number of DB-specific SQL features that this does not implement. There are a bunch of normal ANSI features also not present. See the bottom of this module for some examples, and run it (i.e. ``python sql.py``) to see the results of those examples. """ ######################################## # Constants ######################################## import fnmatch import operator import re import threading import types import weakref from . import classregistry from .converters import registerConverter, sqlrepr, quote_str, unquote_str from .compat import PY2, string_type class VersionError(Exception): pass class NoDefault: pass class SQLObjectState(object): def __init__(self, soObject, connection=None): self.soObject = weakref.proxy(soObject) self.connection = connection safeSQLRE = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_\.]*$') def sqlIdentifier(obj): # some db drivers return unicode column names return isinstance(obj, string_type) and bool(safeSQLRE.search(obj.strip())) def execute(expr, executor): if hasattr(expr, 'execute'): return expr.execute(executor) else: return expr def _str_or_sqlrepr(expr, db): if isinstance(expr, string_type): return expr return sqlrepr(expr, db) ######################################## # Expression generation ######################################## class SQLExpression: def __add__(self, other): return SQLOp("+", self, other) def __radd__(self, other): return SQLOp("+", other, self) def __sub__(self, other): return SQLOp("-", self, other) def __rsub__(self, other): return SQLOp("-", other, self) def __mul__(self, other): return SQLOp("*", self, other) def __rmul__(self, other): return SQLOp("*", other, self) def __div__(self, other): return SQLOp("/", self, other) def __rdiv__(self, other): return SQLOp("/", other, self) def __pos__(self): return SQLPrefix("+", self) def __neg__(self): return SQLPrefix("-", self) def __pow__(self, other): return SQLConstant("POW")(self, other) def __rpow__(self, other): return SQLConstant("POW")(other, self) def __abs__(self): return SQLConstant("ABS")(self) def __mod__(self, other): return SQLModulo(self, other) def __rmod__(self, other): return SQLConstant("MOD")(other, self) def __lt__(self, other): return SQLOp("<", self, other) def __le__(self, other): return SQLOp("<=", self, other) def __gt__(self, other): return SQLOp(">", self, other) def __ge__(self, other): return SQLOp(">=", self, other) def __eq__(self, other): if other is None: return ISNULL(self) else: return SQLOp("=", self, other) def __ne__(self, other): if other is None: return ISNOTNULL(self) else: return SQLOp("<>", self, other) def __and__(self, other): return SQLOp("AND", self, other) def __rand__(self, other): return SQLOp("AND", other, self) def __or__(self, other): return SQLOp("OR", self, other) def __ror__(self, other): return SQLOp("OR", other, self) def __invert__(self): return SQLPrefix("NOT", self) def __call__(self, *args): return SQLCall(self, args) def __repr__(self): try: return self.__sqlrepr__(None) except AssertionError: return '<%s %s>' % ( self.__class__.__name__, hex(id(self))[2:]) def __str__(self): return repr(self) def __cmp__(self, other): raise VersionError("Python 2.1+ required") def __rcmp__(self, other): raise VersionError("Python 2.1+ required") def startswith(self, s): return STARTSWITH(self, s) def endswith(self, s): return ENDSWITH(self, s) def contains(self, s): return CONTAINSSTRING(self, s) def components(self): return [] def tablesUsed(self, db): return self.tablesUsedSet(db) def tablesUsedSet(self, db): tables = set() for table in self.tablesUsedImmediate(): if hasattr(table, '__sqlrepr__'): table = sqlrepr(table, db) tables.add(table) for component in self.components(): tables.update(tablesUsedSet(component, db)) return tables def tablesUsedImmediate(self): return [] ####################################### # Converter for SQLExpression instances ####################################### def SQLExprConverter(value, db): return value.__sqlrepr__() registerConverter(SQLExpression, SQLExprConverter) def tablesUsedSet(obj, db): if hasattr(obj, "tablesUsedSet"): return obj.tablesUsedSet(db) else: return {} if PY2: div = operator.div else: div = operator.truediv operatorMap = { "+": operator.add, "/": div, "-": operator.sub, "*": operator.mul, "<": operator.lt, "<=": operator.le, "=": operator.eq, "!=": operator.ne, ">=": operator.ge, ">": operator.gt, "IN": operator.contains, "IS": operator.eq, } class SQLOp(SQLExpression): def __init__(self, op, expr1, expr2): self.op = op.upper() self.expr1 = expr1 self.expr2 = expr2 def __sqlrepr__(self, db): s1 = sqlrepr(self.expr1, db) s2 = sqlrepr(self.expr2, db) if s1[0] != '(' and s1 != 'NULL': s1 = '(' + s1 + ')' if s2[0] != '(' and s2 != 'NULL': s2 = '(' + s2 + ')' return "(%s %s %s)" % (s1, self.op, s2) def components(self): return [self.expr1, self.expr2] def execute(self, executor): if self.op == "AND": return execute(self.expr1, executor) \ and execute(self.expr2, executor) elif self.op == "OR": return execute(self.expr1, executor) \ or execute(self.expr2, executor) else: return operatorMap[self.op.upper()](execute(self.expr1, executor), execute(self.expr2, executor)) registerConverter(SQLOp, SQLExprConverter) class SQLModulo(SQLOp): def __init__(self, expr1, expr2): SQLOp.__init__(self, '%', expr1, expr2) def __sqlrepr__(self, db): if db == 'sqlite': return SQLOp.__sqlrepr__(self, db) s1 = sqlrepr(self.expr1, db) s2 = sqlrepr(self.expr2, db) return "MOD(%s, %s)" % (s1, s2) registerConverter(SQLModulo, SQLExprConverter) class SQLCall(SQLExpression): def __init__(self, expr, args): self.expr = expr self.args = args def __sqlrepr__(self, db): return "%s%s" % (sqlrepr(self.expr, db), sqlrepr(self.args, db)) def components(self): return [self.expr] + list(self.args) def execute(self, executor): raise ValueError("I don't yet know how to locally execute functions") registerConverter(SQLCall, SQLExprConverter) class SQLPrefix(SQLExpression): def __init__(self, prefix, expr): self.prefix = prefix self.expr = expr def __sqlrepr__(self, db): return "%s %s" % (self.prefix, sqlrepr(self.expr, db)) def components(self): return [self.expr] def execute(self, executor): prefix = self.prefix expr = execute(self.expr, executor) if prefix == "+": return expr elif prefix == "-": return -expr elif prefix.upper() == "NOT": return not expr registerConverter(SQLPrefix, SQLExprConverter) class SQLConstant(SQLExpression): def __init__(self, const): self.const = const def __sqlrepr__(self, db): return self.const def execute(self, executor): raise ValueError("I don't yet know how to execute SQL constants") registerConverter(SQLConstant, SQLExprConverter) class SQLTrueClauseClass(SQLExpression): def __sqlrepr__(self, db): return "1 = 1" def execute(self, executor): return 1 SQLTrueClause = SQLTrueClauseClass() registerConverter(SQLTrueClauseClass, SQLExprConverter) ######################################## # Namespaces ######################################## class Field(SQLExpression): def __init__(self, tableName, fieldName): self.tableName = tableName self.fieldName = fieldName def __sqlrepr__(self, db): return self.tableName + "." + self.fieldName def tablesUsedImmediate(self): return [self.tableName] def execute(self, executor): return executor.field(self.tableName, self.fieldName) class SQLObjectField(Field): def __init__(self, tableName, fieldName, original, soClass, column): Field.__init__(self, tableName, fieldName) self.original = original self.soClass = soClass self.column = column def _from_python(self, value): column = self.column if not isinstance(value, SQLExpression) and \ column and column.from_python: value = column.from_python(value, SQLObjectState(self.soClass)) return value def __eq__(self, other): if other is None: return ISNULL(self) other = self._from_python(other) return SQLOp('=', self, other) def __ne__(self, other): if other is None: return ISNOTNULL(self) other = self._from_python(other) return SQLOp('<>', self, other) def startswith(self, s): s = self._from_python(s) return STARTSWITH(self, s) def endswith(self, s): s = self._from_python(s) return ENDSWITH(self, s) def contains(self, s): s = self._from_python(s) return CONTAINSSTRING(self, s) registerConverter(SQLObjectField, SQLExprConverter) class Table(SQLExpression): FieldClass = Field def __init__(self, tableName): self.tableName = tableName def __getattr__(self, attr): if attr.startswith('__'): raise AttributeError return self.FieldClass(self.tableName, attr) def __sqlrepr__(self, db): return _str_or_sqlrepr(self.tableName, db) def execute(self, executor): raise ValueError("Tables don't have values") class SQLObjectTable(Table): FieldClass = SQLObjectField def __init__(self, soClass): self.soClass = soClass assert soClass.sqlmeta.table, ( "Bad table name in class %r: %r" % (soClass, soClass.sqlmeta.table)) Table.__init__(self, soClass.sqlmeta.table) def __getattr__(self, attr): if attr.startswith('__'): raise AttributeError if attr == 'id': return self._getattrFromID(attr) elif attr in self.soClass.sqlmeta.columns: column = self.soClass.sqlmeta.columns[attr] return self._getattrFromColumn(column, attr) elif attr + 'ID' in \ [k for (k, v) in self.soClass.sqlmeta.columns.items() if v.foreignKey]: attr += 'ID' column = self.soClass.sqlmeta.columns[attr] return self._getattrFromColumn(column, attr) else: raise AttributeError( "%s instance has no attribute '%s'" % (self.soClass.__name__, attr)) def _getattrFromID(self, attr): return self.FieldClass(self.tableName, self.soClass.sqlmeta.idName, attr, self.soClass, None) def _getattrFromColumn(self, column, attr): return self.FieldClass(self.tableName, column.dbName, attr, self.soClass, column) class SQLObjectTableWithJoins(SQLObjectTable): def __getattr__(self, attr): if attr + 'ID' in \ [k for (k, v) in self.soClass.sqlmeta.columns.items() if v.foreignKey]: column = self.soClass.sqlmeta.columns[attr + 'ID'] return self._getattrFromForeignKey(column, attr) elif attr in [x.joinMethodName for x in self.soClass.sqlmeta.joins]: join = [x for x in self.soClass.sqlmeta.joins if x.joinMethodName == attr][0] return self._getattrFromJoin(join, attr) else: return SQLObjectTable.__getattr__(self, attr) def _getattrFromForeignKey(self, column, attr): ret = getattr(self, column.name) == \ getattr(self.soClass, '_SO_class_' + column.foreignKey).q.id return ret def _getattrFromJoin(self, join, attr): if hasattr(join, 'otherColumn'): return AND( join.otherClass.q.id == Field(join.intermediateTable, join.otherColumn), Field(join.intermediateTable, join.joinColumn) == self.soClass.q.id) else: return getattr(join.otherClass.q, join.joinColumn) == \ self.soClass.q.id class TableSpace: TableClass = Table def __getattr__(self, attr): if attr.startswith('__'): raise AttributeError return self.TableClass(attr) class ConstantSpace: def __getattr__(self, attr): if attr.startswith('__'): raise AttributeError return SQLConstant(attr) ######################################## # Table aliases ######################################## class AliasField(Field): def __init__(self, tableName, fieldName, alias, aliasTable): Field.__init__(self, tableName, fieldName) self.alias = alias self.aliasTable = aliasTable def __sqlrepr__(self, db): fieldName = self.fieldName if isinstance(fieldName, SQLExpression): fieldName = sqlrepr(fieldName, db) return self.alias + "." + fieldName def tablesUsedImmediate(self): return [self.aliasTable] class AliasTable(Table): as_string = '' # set it to "AS" if your database requires it FieldClass = AliasField _alias_lock = threading.Lock() _alias_counter = 0 def __init__(self, table, alias=None): if hasattr(table, "sqlmeta"): tableName = SQLConstant(table.sqlmeta.table) elif isinstance(table, (Select, Union)): assert alias is not None, \ "Alias name cannot be constructed from Select instances, " \ "please provide an 'alias' keyword." tableName = Subquery('', table) table = None else: tableName = SQLConstant(table) table = None Table.__init__(self, tableName) self.table = table if alias is None: self._alias_lock.acquire() try: AliasTable._alias_counter += 1 alias = "%s_alias%d" % (tableName, AliasTable._alias_counter) finally: self._alias_lock.release() self.alias = alias def __getattr__(self, attr): if attr.startswith('__'): raise AttributeError if self.table: attr = getattr(self.table.q, attr).fieldName return self.FieldClass(self.tableName, attr, self.alias, self) def __sqlrepr__(self, db): return "%s %s %s" % (sqlrepr(self.tableName, db), self.as_string, self.alias) class Alias(SQLExpression): def __init__(self, table, alias=None): self.q = AliasTable(table, alias) def __sqlrepr__(self, db): return sqlrepr(self.q, db) def components(self): return [self.q] class Union(SQLExpression): def __init__(self, *tables): tabs = [] for t in tables: if not isinstance(t, SQLExpression) and hasattr(t, 'sqlmeta'): t = t.sqlmeta.table if isinstance(t, Alias): t = t.q if isinstance(t, Table): t = t.tableName if not isinstance(t, SQLExpression): t = SQLConstant(t) tabs.append(t) self.tables = tabs def __sqlrepr__(self, db): return " UNION ".join([str(sqlrepr(t, db)) for t in self.tables]) ######################################## # SQL Statements ######################################## class Select(SQLExpression): def __init__(self, items=NoDefault, where=NoDefault, groupBy=NoDefault, having=NoDefault, orderBy=NoDefault, limit=NoDefault, join=NoDefault, lazyColumns=False, distinct=False, start=0, end=None, reversed=False, forUpdate=False, clause=NoDefault, staticTables=NoDefault, distinctOn=NoDefault): self.ops = {} if not isinstance(items, (list, tuple, types.GeneratorType)): items = [items] if clause is NoDefault and where is not NoDefault: clause = where if staticTables is NoDefault: staticTables = [] self.ops['items'] = items self.ops['clause'] = clause self.ops['groupBy'] = groupBy self.ops['having'] = having self.ops['orderBy'] = orderBy self.ops['limit'] = limit self.ops['join'] = join self.ops['lazyColumns'] = lazyColumns self.ops['distinct'] = distinct self.ops['distinctOn'] = distinctOn self.ops['start'] = start self.ops['end'] = end self.ops['reversed'] = reversed self.ops['forUpdate'] = forUpdate self.ops['staticTables'] = staticTables def clone(self, **newOps): ops = self.ops.copy() ops.update(newOps) return self.__class__(**ops) def newItems(self, items): return self.clone(items=items) def newClause(self, new_clause): return self.clone(clause=new_clause) def orderBy(self, orderBy): return self.clone(orderBy=orderBy) def unlimited(self): return self.clone(limit=NoDefault, start=0, end=None) def limit(self, limit): self.clone(limit=limit) def lazyColumns(self, value): return self.clone(lazyColumns=value) def reversed(self): return self.clone(reversed=not self.ops.get('reversed', False)) def distinct(self): return self.clone(distinct=True) def filter(self, filter_clause): if filter_clause is None: # None doesn't filter anything, it's just a no-op: return self clause = self.ops['clause'] if isinstance(clause, string_type): clause = SQLConstant('(%s)' % clause) return self.newClause(AND(clause, filter_clause)) def __sqlrepr__(self, db): select = "SELECT" if self.ops['distinct']: select += " DISTINCT" if self.ops['distinctOn'] is not NoDefault: select += " ON(%s)" % _str_or_sqlrepr( self.ops['distinctOn'], db) if not self.ops['lazyColumns']: select += " %s" % ", ".join( [str(_str_or_sqlrepr(v, db)) for v in self.ops['items']]) else: select += " %s" % _str_or_sqlrepr(self.ops['items'][0], db) join = [] join_str = '' if self.ops['join'] is not NoDefault and self.ops['join'] is not None: _join = self.ops['join'] if isinstance(_join, str): join_str = " " + _join elif isinstance(_join, SQLJoin): join.append(_join) else: join.extend(_join) tables = set() for x in self.ops['staticTables']: if isinstance(x, SQLExpression): x = sqlrepr(x, db) tables.add(x) things = list(self.ops['items']) + join if self.ops['clause'] is not NoDefault: things.append(self.ops['clause']) for thing in things: if isinstance(thing, SQLExpression): tables.update(tablesUsedSet(thing, db)) for j in join: t1 = _str_or_sqlrepr(j.table1, db) if t1 in tables: tables.remove(t1) t2 = _str_or_sqlrepr(j.table2, db) if t2 in tables: tables.remove(t2) if tables: select += " FROM %s" % ", ".join(sorted(tables)) elif join: select += " FROM" tablesYet = tables for j in join: if tablesYet and j.table1: sep = ", " else: sep = " " select += sep + sqlrepr(j, db) tablesYet = True if join_str: select += join_str if self.ops['clause'] is not NoDefault: select += " WHERE %s" % _str_or_sqlrepr(self.ops['clause'], db) if self.ops['groupBy'] is not NoDefault: groupBy = _str_or_sqlrepr(self.ops['groupBy'], db) if isinstance(self.ops['groupBy'], (list, tuple)): groupBy = groupBy[1:-1] # Remove parens select += " GROUP BY %s" % groupBy if self.ops['having'] is not NoDefault: select += " HAVING %s" % _str_or_sqlrepr(self.ops['having'], db) if self.ops['orderBy'] is not NoDefault and \ self.ops['orderBy'] is not None: orderBy = self.ops['orderBy'] if self.ops['reversed']: reverser = DESC else: def reverser(x): return x if isinstance(orderBy, (list, tuple)): select += " ORDER BY %s" % ", ".join( [_str_or_sqlrepr(reverser(_x), db) for _x in orderBy]) else: select += " ORDER BY %s" % _str_or_sqlrepr( reverser(orderBy), db) start, end = self.ops['start'], self.ops['end'] if self.ops['limit'] is not NoDefault: end = start + self.ops['limit'] if start or end: from .dbconnection import dbConnectionForScheme select = dbConnectionForScheme(db)._queryAddLimitOffset(select, start, end) if self.ops['forUpdate']: select += " FOR UPDATE" return select registerConverter(Select, SQLExprConverter) class Insert(SQLExpression): def __init__(self, table, valueList=None, values=None, template=NoDefault): self.template = template self.table = table if valueList: if values: raise TypeError("You may only give valueList *or* values") self.valueList = valueList else: self.valueList = [values] def __sqlrepr__(self, db): if not self.valueList: return '' insert = "INSERT INTO %s" % self.table allowNonDict = True template = self.template if (template is NoDefault) and isinstance(self.valueList[0], dict): template = list(sorted(self.valueList[0].keys())) allowNonDict = False if template is not NoDefault: insert += " (%s)" % ", ".join(template) insert += " VALUES " listToJoin = [] listToJoin_app = listToJoin.append for value in self.valueList: if isinstance(value, dict): if template is NoDefault: raise TypeError( "You can't mix non-dictionaries with dictionaries " "in an INSERT if you don't provide a template (%s)" % repr(value)) value = dictToList(template, value) elif not allowNonDict: raise TypeError( "You can't mix non-dictionaries with dictionaries " "in an INSERT if you don't provide a template (%s)" % repr(value)) listToJoin_app("(%s)" % ", ".join([sqlrepr(v, db) for v in value])) insert = "%s%s" % (insert, ", ".join(listToJoin)) return insert registerConverter(Insert, SQLExprConverter) def dictToList(template, dict): list = [] for key in template: list.append(dict[key]) if len(dict.keys()) > len(template): raise TypeError( "Extra entries in dictionary that aren't asked for in template " "(template=%s, dict=%s)" % (repr(template), repr(dict))) return list class Update(SQLExpression): def __init__(self, table, values, template=NoDefault, where=NoDefault): self.table = table self.values = values self.template = template self.whereClause = where def __sqlrepr__(self, db): update = "%s %s" % (self.sqlName(), self.table) update += " SET" first = True if self.template is not NoDefault: for i in range(len(self.template)): if first: first = False else: update += "," update += " %s=%s" % (self.template[i], sqlrepr(self.values[i], db)) else: for key, value in sorted(self.values.items()): if first: first = False else: update += "," update += " %s=%s" % (key, sqlrepr(value, db)) if self.whereClause is not NoDefault: update += " WHERE %s" % _str_or_sqlrepr(self.whereClause, db) return update def sqlName(self): return "UPDATE" registerConverter(Update, SQLExprConverter) class Delete(SQLExpression): """To be safe, this will signal an error if there is no where clause, unless you pass in where=None to the constructor.""" def __init__(self, table, where=NoDefault): self.table = table if where is NoDefault: raise TypeError( "You must give a where clause or pass in None " "to indicate no where clause") self.whereClause = where def __sqlrepr__(self, db): whereClause = self.whereClause if whereClause is None: return "DELETE FROM %s" % self.table whereClause = _str_or_sqlrepr(whereClause, db) return "DELETE FROM %s WHERE %s" % (self.table, whereClause) registerConverter(Delete, SQLExprConverter) class Replace(Update): def sqlName(self): return "REPLACE" registerConverter(Replace, SQLExprConverter) ######################################## # SQL Builtins ######################################## class DESC(SQLExpression): def __init__(self, expr): self.expr = expr def __sqlrepr__(self, db): if isinstance(self.expr, DESC): return sqlrepr(self.expr.expr, db) return '%s DESC' % sqlrepr(self.expr, db) def AND(*ops): if not ops: return None op1 = ops[0] ops = ops[1:] if ops: return SQLOp("AND", op1, AND(*ops)) else: return op1 def OR(*ops): if not ops: return None op1 = ops[0] ops = ops[1:] if ops: return SQLOp("OR", op1, OR(*ops)) else: return op1 def NOT(op): return SQLPrefix("NOT", op) def _IN(item, list): return SQLOp("IN", item, list) def IN(item, list): from .sresults import SelectResults # Import here to avoid circular import if isinstance(list, SelectResults): query = list.queryForSelect() query.ops['items'] = [list.sourceClass.q.id] list = query if isinstance(list, Select): return INSubquery(item, list) else: return _IN(item, list) def NOTIN(item, list): if isinstance(list, Select): return NOTINSubquery(item, list) else: return NOT(_IN(item, list)) def STARTSWITH(expr, pattern): return LIKE(expr, _LikeQuoted(pattern) + '%', escape='\\') def ENDSWITH(expr, pattern): return LIKE(expr, '%' + _LikeQuoted(pattern), escape='\\') def CONTAINSSTRING(expr, pattern): return LIKE(expr, '%' + _LikeQuoted(pattern) + '%', escape='\\') def ISNULL(expr): return SQLOp("IS", expr, None) def ISNOTNULL(expr): return SQLOp("IS NOT", expr, None) class ColumnAS(SQLOp): ''' Just like SQLOp('AS', expr, name) except without the parentheses ''' def __init__(self, expr, name): if isinstance(name, string_type): name = SQLConstant(name) SQLOp.__init__(self, 'AS', expr, name) def __sqlrepr__(self, db): return "%s %s %s" % (sqlrepr(self.expr1, db), self.op, sqlrepr(self.expr2, db)) class _LikeQuoted: # It assumes prefix and postfix are strings; usually just a percent sign. # @@: I'm not sure what the quoting rules really are for all the # databases def __init__(self, expr): self.expr = expr self.prefix = '' self.postfix = '' def __radd__(self, s): self.prefix = s + self.prefix return self def __add__(self, s): self.postfix += s return self def __sqlrepr__(self, db): s = self.expr if isinstance(s, SQLExpression): values = [] if self.prefix: values.append(quote_str(self.prefix, db)) s = _quote_like_special(sqlrepr(s, db), db) values.append(s) if self.postfix: values.append(quote_str(self.postfix, db)) if db == "mysql": return "CONCAT(%s)" % ", ".join(values) else: return " || ".join(values) elif isinstance(s, string_type): s = _quote_like_special(unquote_str(sqlrepr(s, db)), db) return quote_str("%s%s%s" % (self.prefix, s, self.postfix), db) else: raise TypeError( "expected str, unicode or SQLExpression, got %s" % type(s)) def _quote_like_special(s, db): if db in ('postgres', 'rdbhost'): escape = r'\\' else: escape = '\\' s = s.replace('\\', r'\\').\ replace('%', escape + '%').\ replace('_', escape + '_') return s class CONCAT(SQLExpression): def __init__(self, *expressions): self.expressions = expressions def __sqlrepr__(self, db): values = [sqlrepr(expr, db) for expr in self.expressions] if db == "mysql": return "CONCAT(%s)" % ", ".join(values) else: return " || ".join(values) ######################################## # SQL JOINs ######################################## class SQLJoin(SQLExpression): def __init__(self, table1, table2, op=','): if hasattr(table1, 'sqlmeta'): table1 = table1.sqlmeta.table if hasattr(table2, 'sqlmeta'): table2 = table2.sqlmeta.table if isinstance(table1, str): table1 = SQLConstant(table1) if isinstance(table2, str): table2 = SQLConstant(table2) self.table1 = table1 self.table2 = table2 self.op = op def __sqlrepr__(self, db): if self.table1: return "%s%s %s" % (sqlrepr(self.table1, db), self.op, sqlrepr(self.table2, db)) else: return "%s %s" % (self.op, sqlrepr(self.table2, db)) registerConverter(SQLJoin, SQLExprConverter) def JOIN(table1, table2): return SQLJoin(table1, table2, " JOIN") def INNERJOIN(table1, table2): return SQLJoin(table1, table2, " INNER JOIN") def CROSSJOIN(table1, table2): return SQLJoin(table1, table2, " CROSS JOIN") def STRAIGHTJOIN(table1, table2): return SQLJoin(table1, table2, " STRAIGHT JOIN") def LEFTJOIN(table1, table2): return SQLJoin(table1, table2, " LEFT JOIN") def LEFTOUTERJOIN(table1, table2): return SQLJoin(table1, table2, " LEFT OUTER JOIN") def NATURALJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL JOIN") def NATURALLEFTJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL LEFT JOIN") def NATURALLEFTOUTERJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL LEFT OUTER JOIN") def RIGHTJOIN(table1, table2): return SQLJoin(table1, table2, " RIGHT JOIN") def RIGHTOUTERJOIN(table1, table2): return SQLJoin(table1, table2, " RIGHT OUTER JOIN") def NATURALRIGHTJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL RIGHT JOIN") def NATURALRIGHTOUTERJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL RIGHT OUTER JOIN") def FULLJOIN(table1, table2): return SQLJoin(table1, table2, " FULL JOIN") def FULLOUTERJOIN(table1, table2): return SQLJoin(table1, table2, " FULL OUTER JOIN") def NATURALFULLJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL FULL JOIN") def NATURALFULLOUTERJOIN(table1, table2): return SQLJoin(table1, table2, " NATURAL FULL OUTER JOIN") class SQLJoinConditional(SQLJoin): """Conditional JOIN""" def __init__(self, table1, table2, op, on_condition=None, using_columns=None): """For condition you must give on_condition or using_columns but not both on_condition can be a string or SQLExpression, for example Table1.q.col1 == Table2.q.col2 using_columns can be a string or a list of columns, e.g. (Table1.q.col1, Table2.q.col2) """ if not on_condition and not using_columns: raise TypeError("You must give ON condition or USING columns") if on_condition and using_columns: raise TypeError( "You must give ON condition or USING columns but not both") SQLJoin.__init__(self, table1, table2, op) self.on_condition = on_condition self.using_columns = using_columns def __sqlrepr__(self, db): if self.on_condition: on_condition = self.on_condition if hasattr(on_condition, "__sqlrepr__"): on_condition = sqlrepr(on_condition, db) join = "%s %s ON %s" % (self.op, sqlrepr(self.table2, db), on_condition) if self.table1: join = "%s %s" % (sqlrepr(self.table1, db), join) return join elif self.using_columns: using_columns = [] for col in self.using_columns: if hasattr(col, "__sqlrepr__"): col = sqlrepr(col, db) using_columns.append(col) using_columns = ", ".join(using_columns) join = "%s %s USING (%s)" % (self.op, sqlrepr(self.table2, db), using_columns) if self.table1: join = "%s %s" % (sqlrepr(self.table1, db), join) return join else: RuntimeError, "Impossible error" registerConverter(SQLJoinConditional, SQLExprConverter) def INNERJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "INNER JOIN", on_condition, using_columns) def LEFTJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "LEFT JOIN", on_condition, using_columns) def LEFTOUTERJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "LEFT OUTER JOIN", on_condition, using_columns) def RIGHTJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "RIGHT JOIN", on_condition, using_columns) def RIGHTOUTERJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "RIGHT OUTER JOIN", on_condition, using_columns) def FULLJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "FULL JOIN", on_condition, using_columns) def FULLOUTERJOINConditional(table1, table2, on_condition=None, using_columns=None): return SQLJoinConditional(table1, table2, "FULL OUTER JOIN", on_condition, using_columns) class SQLJoinOn(SQLJoinConditional): """Conditional JOIN ON""" def __init__(self, table1, table2, op, on_condition): SQLJoinConditional.__init__(self, table1, table2, op, on_condition) registerConverter(SQLJoinOn, SQLExprConverter) class SQLJoinUsing(SQLJoinConditional): """Conditional JOIN USING""" def __init__(self, table1, table2, op, using_columns): SQLJoinConditional.__init__(self, table1, table2, op, None, using_columns) registerConverter(SQLJoinUsing, SQLExprConverter) def INNERJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "INNER JOIN", on_condition) def LEFTJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "LEFT JOIN", on_condition) def LEFTOUTERJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "LEFT OUTER JOIN", on_condition) def RIGHTJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "RIGHT JOIN", on_condition) def RIGHTOUTERJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "RIGHT OUTER JOIN", on_condition) def FULLJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "FULL JOIN", on_condition) def FULLOUTERJOINOn(table1, table2, on_condition): return SQLJoinOn(table1, table2, "FULL OUTER JOIN", on_condition) def INNERJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "INNER JOIN", using_columns) def LEFTJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "LEFT JOIN", using_columns) def LEFTOUTERJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "LEFT OUTER JOIN", using_columns) def RIGHTJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "RIGHT JOIN", using_columns) def RIGHTOUTERJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "RIGHT OUTER JOIN", using_columns) def FULLJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "FULL JOIN", using_columns) def FULLOUTERJOINUsing(table1, table2, using_columns): return SQLJoinUsing(table1, table2, "FULL OUTER JOIN", using_columns) ######################################## # Subqueries (subselects) ######################################## class OuterField(SQLObjectField): def tablesUsedImmediate(self): return [] class OuterTable(SQLObjectTable): FieldClass = OuterField class Outer: def __init__(self, table): self.q = OuterTable(table) class LIKE(SQLExpression): op = "LIKE" def __init__(self, expr, string, escape=None): self.expr = expr self.string = string self.escape = escape def __sqlrepr__(self, db): escape = self.escape like = "%s %s (%s)" % (sqlrepr(self.expr, db), self.op, sqlrepr(self.string, db)) if escape is None: return "(%s)" % like else: return "(%s ESCAPE %s)" % (like, sqlrepr(escape, db)) def components(self): return [self.expr, self.string] def execute(self, executor): if not hasattr(self, '_regex'): # @@: Crude, not entirely accurate dest = self.string dest = dest.replace("%%", "\001") dest = dest.replace("*", "\002") dest = dest.replace("%", "*") dest = dest.replace("\001", "%") dest = dest.replace("\002", "[*]") self._regex = re.compile(fnmatch.translate(dest), re.I) return self._regex.search(execute(self.expr, executor)) class RLIKE(LIKE): op = "RLIKE" op_db = { 'firebird': 'RLIKE', 'maxdb': 'RLIKE', 'mysql': 'RLIKE', 'postgres': '~', 'rdbhost': '~', 'sqlite': 'REGEXP' } def _get_op(self, db): return self.op_db.get(db, 'LIKE') def __sqlrepr__(self, db): return "(%s %s (%s))" % ( sqlrepr(self.expr, db), self._get_op(db), sqlrepr(self.string, db) ) def execute(self, executor): self.op = self._get_op(self.db) return LIKE.execute(self, executor) class INSubquery(SQLExpression): op = "IN" def __init__(self, item, subquery): self.item = item self.subquery = subquery def components(self): return [self.item] def __sqlrepr__(self, db): return "%s %s (%s)" % (sqlrepr(self.item, db), self.op, sqlrepr(self.subquery, db)) class NOTINSubquery(INSubquery): op = "NOT IN" class Subquery(SQLExpression): def __init__(self, op, subquery): self.op = op self.subquery = subquery def __sqlrepr__(self, db): return "%s (%s)" % (self.op, sqlrepr(self.subquery, db)) def EXISTS(subquery): return Subquery("EXISTS", subquery) def NOTEXISTS(subquery): return Subquery("NOT EXISTS", subquery) def SOME(subquery): return Subquery("SOME", subquery) def ANY(subquery): return Subquery("ANY", subquery) def ALL(subquery): return Subquery("ALL", subquery) #### class ImportProxyField(SQLObjectField): def tablesUsedImmediate(self): return [str(self.tableName)] class ImportProxy(SQLExpression): '''Class to be used in column definitions that rely on other tables that might not yet be in a classregistry. ''' FieldClass = ImportProxyField def __init__(self, clsName, registry=None): self.tableName = _DelayClass(self, clsName) self.sqlmeta = _Delay_proxy(table=_DelayClass(self, clsName)) self.q = self self.soClass = None classregistry.registry(registry).addClassCallback( clsName, lambda foreign, me: setattr(me, 'soClass', foreign), self) def __nonzero__(self): return True def __getattr__(self, attr): if self.soClass is None: return _Delay(self, attr) return getattr(self.soClass.q, attr) class _Delay(SQLExpression): def __init__(self, proxy, attr): self.attr = attr self.proxy = proxy def __sqlrepr__(self, db): if self.proxy.soClass is None: return '_DELAYED_' + self.attr val = self._resolve() if isinstance(val, SQLExpression): val = sqlrepr(val, db) return val def tablesUsedImmediate(self): return getattr(self._resolve(), 'tablesUsedImmediate', lambda: [])() def components(self): return getattr(self._resolve(), 'components', lambda: [])() def _resolve(self): return getattr(self.proxy, self.attr) # For AliasTable etc def fieldName(self): class _aliasFieldName(SQLExpression): def __init__(self, proxy): self.proxy = proxy def __sqlrepr__(self, db): return self.proxy._resolve().fieldName return _aliasFieldName(self) fieldName = property(fieldName) class _DelayClass(_Delay): def _resolve(self): return self.proxy.soClass.sqlmeta.table class _Delay_proxy(object): def __init__(self, **kw): self.__dict__.update(kw) ###### ######################################## # Global initializations ######################################## table = TableSpace() const = ConstantSpace() func = const ######################################## # Testing ######################################## if __name__ == "__main__": tests = """ >>> AND(table.address.name == "Ian Bicking", table.address.zip > 30000) >>> table.address.name >>> AND(LIKE(table.address.name, "this"), IN(table.address.zip, [100, 200, 300])) >>> Select([table.address.name, table.address.state], where=LIKE(table.address.name, "%ian%")) >>> Select([table.user.name], where=AND(table.user.state == table.states.abbrev)) >>> Insert(table.address, [{"name": "BOB", "address": "3049 N. 18th St."}, {"name": "TIM", "address": "409 S. 10th St."}]) >>> Insert(table.address, [("BOB", "3049 N. 18th St."), ("TIM", "409 S. 10th St.")], template=('name', 'address')) >>> Delete(table.address, where="BOB"==table.address.name) >>> Update(table.address, {"lastModified": const.NOW()}) >>> Replace(table.address, [("BOB", "3049 N. 18th St."), ("TIM", "409 S. 10th St.")], template=('name', 'address')) """ # noqa: allow long (> 79) lines for expr in tests.split('\n'): if not expr.strip(): continue if expr.startswith('>>> '): expr = expr[4:] SQLObject-3.1.0/SQLObject.egg-info/0000755000175000017500000000000012754657361016151 5ustar phdphd00000000000000SQLObject-3.1.0/SQLObject.egg-info/entry_points.txt0000644000175000017500000000013112754657355021445 0ustar phdphd00000000000000 [paste.filter_app_factory] main = sqlobject.wsgi_middleware:make_middleware SQLObject-3.1.0/SQLObject.egg-info/dependency_links.txt0000644000175000017500000000000112754657355022222 0ustar phdphd00000000000000 SQLObject-3.1.0/SQLObject.egg-info/SOURCES.txt0000644000175000017500000013134112754657356020044 0ustar phdphd00000000000000.gitignore .travis.yml MANIFEST.in README.rst circle.yml ez_setup.py requirements.txt requirements_dev.txt requirements_docs.txt setup.cfg setup.py tox.ini SQLObject.egg-info/PKG-INFO SQLObject.egg-info/SOURCES.txt SQLObject.egg-info/dependency_links.txt SQLObject.egg-info/entry_points.txt SQLObject.egg-info/requires.txt SQLObject.egg-info/top_level.txt debian/changelog debian/control debian/copyright debian/docs debian/examples debian/rules docs/.gitignore docs/Authors.rst docs/DeveloperGuide.rst docs/FAQ.rst docs/Inheritance.rst docs/LICENSE docs/News.rst docs/News1.rst docs/News2.rst docs/News3.rst docs/News4.rst docs/News5.rst docs/Python3.rst docs/SQLBuilder.rst docs/SQLObject.rst docs/SelectResults.rst docs/TODO.rst docs/Versioning.rst docs/Views.rst docs/community.rst docs/default.css docs/download.rst docs/index.rst docs/interface.py docs/links.rst docs/rebuild docs/sqlobject-admin.rst docs/test.py docs/europython/europython_sqlobj.py docs/europython/main.css docs/europython/person.py docs/html/Authors.html docs/html/DeveloperGuide.html docs/html/FAQ.html docs/html/Inheritance.html docs/html/News.html docs/html/News1.html docs/html/News2.html docs/html/News3.html docs/html/News4.html docs/html/News5.html docs/html/Python3.html docs/html/SQLBuilder.html docs/html/SQLObject.html docs/html/SelectResults.html docs/html/TODO.html docs/html/Versioning.html docs/html/Views.html docs/html/class-sqlobject.boundattributes.BoundAttribute.html docs/html/class-sqlobject.boundattributes.BoundFactory.html docs/html/class-sqlobject.cache.CacheFactory.html docs/html/class-sqlobject.cache.CacheSet.html docs/html/class-sqlobject.classregistry.ClassRegistry.html docs/html/class-sqlobject.col.BLOBCol.html docs/html/class-sqlobject.col.BigIntCol.html docs/html/class-sqlobject.col.BoolCol.html docs/html/class-sqlobject.col.Col.html docs/html/class-sqlobject.col.CurrencyCol.html docs/html/class-sqlobject.col.DateCol.html docs/html/class-sqlobject.col.DateTimeCol.html docs/html/class-sqlobject.col.DecimalCol.html docs/html/class-sqlobject.col.DecimalStringCol.html docs/html/class-sqlobject.col.EnumCol.html docs/html/class-sqlobject.col.FloatCol.html docs/html/class-sqlobject.col.ForeignKey.html docs/html/class-sqlobject.col.IntCol.html docs/html/class-sqlobject.col.JSONCol.html docs/html/class-sqlobject.col.JsonbCol.html docs/html/class-sqlobject.col.KeyCol.html docs/html/class-sqlobject.col.MediumIntCol.html docs/html/class-sqlobject.col.PickleCol.html docs/html/class-sqlobject.col.SOBLOBCol.html docs/html/class-sqlobject.col.SOBigIntCol.html docs/html/class-sqlobject.col.SOBoolCol.html docs/html/class-sqlobject.col.SOCol.html docs/html/class-sqlobject.col.SOCurrencyCol.html docs/html/class-sqlobject.col.SODateCol.html docs/html/class-sqlobject.col.SODateTimeCol.html docs/html/class-sqlobject.col.SODecimalCol.html docs/html/class-sqlobject.col.SODecimalStringCol.html docs/html/class-sqlobject.col.SOEnumCol.html docs/html/class-sqlobject.col.SOFloatCol.html docs/html/class-sqlobject.col.SOForeignKey.html docs/html/class-sqlobject.col.SOIntCol.html docs/html/class-sqlobject.col.SOJSONCol.html docs/html/class-sqlobject.col.SOJsonbCol.html docs/html/class-sqlobject.col.SOKeyCol.html docs/html/class-sqlobject.col.SOMediumIntCol.html docs/html/class-sqlobject.col.SOPickleCol.html docs/html/class-sqlobject.col.SOSetCol.html docs/html/class-sqlobject.col.SOSmallIntCol.html docs/html/class-sqlobject.col.SOStringCol.html docs/html/class-sqlobject.col.SOStringLikeCol.html docs/html/class-sqlobject.col.SOTimeCol.html docs/html/class-sqlobject.col.SOTimedeltaCol.html docs/html/class-sqlobject.col.SOTimestampCol.html docs/html/class-sqlobject.col.SOTinyIntCol.html docs/html/class-sqlobject.col.SOUnicodeCol.html docs/html/class-sqlobject.col.SOUuidCol.html docs/html/class-sqlobject.col.SetCol.html docs/html/class-sqlobject.col.SmallIntCol.html docs/html/class-sqlobject.col.StringCol.html docs/html/class-sqlobject.col.TimeCol.html docs/html/class-sqlobject.col.TimedeltaCol.html docs/html/class-sqlobject.col.TimestampCol.html docs/html/class-sqlobject.col.TinyIntCol.html docs/html/class-sqlobject.col.UnicodeCol.html docs/html/class-sqlobject.col.UuidCol.html docs/html/class-sqlobject.constraints.BadValue.html docs/html/class-sqlobject.constraints.InList.html docs/html/class-sqlobject.constraints.MaxLength.html docs/html/class-sqlobject.converters.ConverterRegistry.html docs/html/class-sqlobject.dbconnection.Boolean.html docs/html/class-sqlobject.dbconnection.ConnMethodWrapper.html docs/html/class-sqlobject.dbconnection.ConnWrapper.html docs/html/class-sqlobject.dbconnection.ConnectionHub.html docs/html/class-sqlobject.dbconnection.ConnectionURIOpener.html docs/html/class-sqlobject.dbconnection.ConsoleWriter.html docs/html/class-sqlobject.dbconnection.DBAPI.html docs/html/class-sqlobject.dbconnection.DBConnection.html docs/html/class-sqlobject.dbconnection.Iteration.html docs/html/class-sqlobject.dbconnection.LogWriter.html docs/html/class-sqlobject.dbconnection.Transaction.html docs/html/class-sqlobject.dberrors.DataError.html docs/html/class-sqlobject.dberrors.DatabaseError.html docs/html/class-sqlobject.dberrors.DuplicateEntryError.html docs/html/class-sqlobject.dberrors.Error.html docs/html/class-sqlobject.dberrors.IntegrityError.html docs/html/class-sqlobject.dberrors.InterfaceError.html docs/html/class-sqlobject.dberrors.InternalError.html docs/html/class-sqlobject.dberrors.NotSupportedError.html docs/html/class-sqlobject.dberrors.OperationalError.html docs/html/class-sqlobject.dberrors.ProgrammingError.html docs/html/class-sqlobject.dberrors.Warning.html docs/html/class-sqlobject.declarative.Declarative.html docs/html/class-sqlobject.declarative.DeclarativeMeta.html docs/html/class-sqlobject.declarative.classinstancemethod.html docs/html/class-sqlobject.events.AddColumnSignal.html docs/html/class-sqlobject.events.ClassCreateSignal.html docs/html/class-sqlobject.events.CreateTableSignal.html docs/html/class-sqlobject.events.DeleteColumnSignal.html docs/html/class-sqlobject.events.DropTableSignal.html docs/html/class-sqlobject.events.RowCreateSignal.html docs/html/class-sqlobject.events.RowCreatedSignal.html docs/html/class-sqlobject.events.RowDestroySignal.html docs/html/class-sqlobject.events.RowDestroyedSignal.html docs/html/class-sqlobject.events.RowUpdateSignal.html docs/html/class-sqlobject.events.RowUpdatedSignal.html docs/html/class-sqlobject.events.Signal.html docs/html/class-sqlobject.firebird.firebirdconnection.FirebirdConnection.html docs/html/class-sqlobject.include.hashcol.HashCol.html docs/html/class-sqlobject.include.tests.test_hashcol.HashTest.html docs/html/class-sqlobject.index.DatabaseIndex.html docs/html/class-sqlobject.inheritance.InheritableSQLObject.html docs/html/class-sqlobject.joins.ManyToMany.html docs/html/class-sqlobject.joins.MultipleJoin.html docs/html/class-sqlobject.joins.OneToMany.html docs/html/class-sqlobject.joins.RelatedJoin.html docs/html/class-sqlobject.joins.SQLMultipleJoin.html docs/html/class-sqlobject.joins.SQLRelatedJoin.html docs/html/class-sqlobject.joins.SingleJoin.html docs/html/class-sqlobject.main.NoDefault.html docs/html/class-sqlobject.main.SQLObject.html docs/html/class-sqlobject.main.SQLObjectIntegrityError.html docs/html/class-sqlobject.main.SQLObjectNotFound.html docs/html/class-sqlobject.main.sqlmeta.html docs/html/class-sqlobject.manager.command.Command.html docs/html/class-sqlobject.manager.command.CommandCreate.html docs/html/class-sqlobject.manager.command.CommandDrop.html docs/html/class-sqlobject.manager.command.CommandExecute.html docs/html/class-sqlobject.manager.command.CommandHelp.html docs/html/class-sqlobject.manager.command.CommandList.html docs/html/class-sqlobject.manager.command.CommandRecord.html docs/html/class-sqlobject.manager.command.CommandRunner.html docs/html/class-sqlobject.manager.command.CommandSQL.html docs/html/class-sqlobject.manager.command.CommandStatus.html docs/html/class-sqlobject.manager.command.CommandUpgrade.html docs/html/class-sqlobject.manager.command.SQLObjectVersionTable.html docs/html/class-sqlobject.maxdb.maxdbconnection.IncorrectIDStyleError.html docs/html/class-sqlobject.maxdb.maxdbconnection.LowerBoundOfSliceIsNotSupported.html docs/html/class-sqlobject.maxdb.maxdbconnection.MaxdbConnection.html docs/html/class-sqlobject.maxdb.maxdbconnection.PrimaryKeyNotFounded.html docs/html/class-sqlobject.maxdb.maxdbconnection.StyleMismatchError.html docs/html/class-sqlobject.maxdb.maxdbconnection.maxdbException.html docs/html/class-sqlobject.mssql.mssqlconnection.MSSQLConnection.html docs/html/class-sqlobject.mysql.mysqlconnection.ErrorMessage.html docs/html/class-sqlobject.mysql.mysqlconnection.MySQLConnection.html docs/html/class-sqlobject.postgres.pgconnection.ErrorMessage.html docs/html/class-sqlobject.postgres.pgconnection.PostgresConnection.html docs/html/class-sqlobject.rdbhost.rdbhostconnection.RdbhostConnection.html docs/html/class-sqlobject.sqlbuilder.Alias.html docs/html/class-sqlobject.sqlbuilder.AliasField.html docs/html/class-sqlobject.sqlbuilder.AliasTable.html docs/html/class-sqlobject.sqlbuilder.CONCAT.html docs/html/class-sqlobject.sqlbuilder.ColumnAS.html docs/html/class-sqlobject.sqlbuilder.ConstantSpace.html docs/html/class-sqlobject.sqlbuilder.DESC.html docs/html/class-sqlobject.sqlbuilder.Delete.html docs/html/class-sqlobject.sqlbuilder.Field.html docs/html/class-sqlobject.sqlbuilder.INSubquery.html docs/html/class-sqlobject.sqlbuilder.ImportProxy.html docs/html/class-sqlobject.sqlbuilder.ImportProxyField.html docs/html/class-sqlobject.sqlbuilder.Insert.html docs/html/class-sqlobject.sqlbuilder.LIKE.html docs/html/class-sqlobject.sqlbuilder.NOTINSubquery.html docs/html/class-sqlobject.sqlbuilder.NoDefault.html docs/html/class-sqlobject.sqlbuilder.Outer.html docs/html/class-sqlobject.sqlbuilder.OuterField.html docs/html/class-sqlobject.sqlbuilder.OuterTable.html docs/html/class-sqlobject.sqlbuilder.RLIKE.html docs/html/class-sqlobject.sqlbuilder.Replace.html docs/html/class-sqlobject.sqlbuilder.SQLCall.html docs/html/class-sqlobject.sqlbuilder.SQLConstant.html docs/html/class-sqlobject.sqlbuilder.SQLExpression.html docs/html/class-sqlobject.sqlbuilder.SQLJoin.html docs/html/class-sqlobject.sqlbuilder.SQLJoinConditional.html docs/html/class-sqlobject.sqlbuilder.SQLJoinOn.html docs/html/class-sqlobject.sqlbuilder.SQLJoinUsing.html docs/html/class-sqlobject.sqlbuilder.SQLModulo.html docs/html/class-sqlobject.sqlbuilder.SQLObjectField.html docs/html/class-sqlobject.sqlbuilder.SQLObjectState.html docs/html/class-sqlobject.sqlbuilder.SQLObjectTable.html docs/html/class-sqlobject.sqlbuilder.SQLObjectTableWithJoins.html docs/html/class-sqlobject.sqlbuilder.SQLOp.html docs/html/class-sqlobject.sqlbuilder.SQLPrefix.html docs/html/class-sqlobject.sqlbuilder.SQLTrueClauseClass.html docs/html/class-sqlobject.sqlbuilder.Select.html docs/html/class-sqlobject.sqlbuilder.Subquery.html docs/html/class-sqlobject.sqlbuilder.Table.html docs/html/class-sqlobject.sqlbuilder.TableSpace.html docs/html/class-sqlobject.sqlbuilder.Union.html docs/html/class-sqlobject.sqlbuilder.Update.html docs/html/class-sqlobject.sqlbuilder.VersionError.html docs/html/class-sqlobject.sqlite.sqliteconnection.ErrorMessage.html docs/html/class-sqlobject.sqlite.sqliteconnection.SQLiteConnection.html docs/html/class-sqlobject.sresults.SelectResults.html docs/html/class-sqlobject.styles.DefaultStyle.html docs/html/class-sqlobject.styles.MixedCaseStyle.html docs/html/class-sqlobject.styles.MixedCaseUnderscoreStyle.html docs/html/class-sqlobject.styles.Style.html docs/html/class-sqlobject.sybase.sybaseconnection.SybaseConnection.html docs/html/class-sqlobject.versioning.Version.html docs/html/class-sqlobject.versioning.Versioning.html docs/html/class-sqlobject.views.ViewSQLObject.html docs/html/class-sqlobject.views.ViewSQLObjectField.html docs/html/class-sqlobject.views.ViewSQLObjectTable.html docs/html/community.html docs/html/download.html docs/html/index.html docs/html/layout.css docs/html/links.html docs/html/module-index.html docs/html/module-sqlobject-index.html docs/html/module-sqlobject.__version__-index.html docs/html/module-sqlobject.__version__.html docs/html/module-sqlobject.boundattributes-index.html docs/html/module-sqlobject.boundattributes.html docs/html/module-sqlobject.cache-index.html docs/html/module-sqlobject.cache.html docs/html/module-sqlobject.classregistry-index.html docs/html/module-sqlobject.classregistry.html docs/html/module-sqlobject.col-index.html docs/html/module-sqlobject.col.html docs/html/module-sqlobject.compat-index.html docs/html/module-sqlobject.compat.html docs/html/module-sqlobject.constraints-index.html docs/html/module-sqlobject.constraints.html docs/html/module-sqlobject.converters-index.html docs/html/module-sqlobject.converters.html docs/html/module-sqlobject.dbconnection-index.html docs/html/module-sqlobject.dbconnection.html docs/html/module-sqlobject.dberrors-index.html docs/html/module-sqlobject.dberrors.html docs/html/module-sqlobject.declarative-index.html docs/html/module-sqlobject.declarative.html docs/html/module-sqlobject.events-index.html docs/html/module-sqlobject.events.html docs/html/module-sqlobject.firebird-index.html docs/html/module-sqlobject.firebird.firebirdconnection-index.html docs/html/module-sqlobject.firebird.firebirdconnection.html docs/html/module-sqlobject.firebird.html docs/html/module-sqlobject.html docs/html/module-sqlobject.include-index.html docs/html/module-sqlobject.include.hashcol-index.html docs/html/module-sqlobject.include.hashcol.html docs/html/module-sqlobject.include.html docs/html/module-sqlobject.include.tests-index.html docs/html/module-sqlobject.include.tests.html docs/html/module-sqlobject.include.tests.test_hashcol-index.html docs/html/module-sqlobject.include.tests.test_hashcol.html docs/html/module-sqlobject.index-index.html docs/html/module-sqlobject.index.html docs/html/module-sqlobject.inheritance-index.html docs/html/module-sqlobject.inheritance.html docs/html/module-sqlobject.joins-index.html docs/html/module-sqlobject.joins.html docs/html/module-sqlobject.main-index.html docs/html/module-sqlobject.main.html docs/html/module-sqlobject.manager-index.html docs/html/module-sqlobject.manager.command-index.html docs/html/module-sqlobject.manager.command.html docs/html/module-sqlobject.manager.html docs/html/module-sqlobject.maxdb-index.html docs/html/module-sqlobject.maxdb.html docs/html/module-sqlobject.maxdb.maxdbconnection-index.html docs/html/module-sqlobject.maxdb.maxdbconnection.html docs/html/module-sqlobject.mssql-index.html docs/html/module-sqlobject.mssql.html docs/html/module-sqlobject.mssql.mssqlconnection-index.html docs/html/module-sqlobject.mssql.mssqlconnection.html docs/html/module-sqlobject.mysql-index.html docs/html/module-sqlobject.mysql.html docs/html/module-sqlobject.mysql.mysqlconnection-index.html docs/html/module-sqlobject.mysql.mysqlconnection.html docs/html/module-sqlobject.postgres-index.html docs/html/module-sqlobject.postgres.html docs/html/module-sqlobject.postgres.pgconnection-index.html docs/html/module-sqlobject.postgres.pgconnection.html docs/html/module-sqlobject.rdbhost-index.html docs/html/module-sqlobject.rdbhost.html docs/html/module-sqlobject.rdbhost.rdbhostconnection-index.html docs/html/module-sqlobject.rdbhost.rdbhostconnection.html docs/html/module-sqlobject.sqlbuilder-index.html docs/html/module-sqlobject.sqlbuilder.html docs/html/module-sqlobject.sqlite-index.html docs/html/module-sqlobject.sqlite.html docs/html/module-sqlobject.sqlite.sqliteconnection-index.html docs/html/module-sqlobject.sqlite.sqliteconnection.html docs/html/module-sqlobject.sresults-index.html docs/html/module-sqlobject.sresults.html docs/html/module-sqlobject.styles-index.html docs/html/module-sqlobject.styles.html docs/html/module-sqlobject.sybase-index.html docs/html/module-sqlobject.sybase.html docs/html/module-sqlobject.sybase.sybaseconnection-index.html docs/html/module-sqlobject.sybase.sybaseconnection.html docs/html/module-sqlobject.util-index.html docs/html/module-sqlobject.util.csvexport-index.html docs/html/module-sqlobject.util.csvexport.html docs/html/module-sqlobject.util.csvimport-index.html docs/html/module-sqlobject.util.csvimport.html docs/html/module-sqlobject.util.html docs/html/module-sqlobject.util.moduleloader-index.html docs/html/module-sqlobject.util.moduleloader.html docs/html/module-sqlobject.util.threadinglocal-index.html docs/html/module-sqlobject.util.threadinglocal.html docs/html/module-sqlobject.versioning-index.html docs/html/module-sqlobject.versioning.html docs/html/module-sqlobject.views-index.html docs/html/module-sqlobject.views.html docs/html/pudge.css docs/html/rst.css docs/html/site.css docs/html/sqlobject-admin.html docs/html/sqlobject/__init__.py.html docs/html/sqlobject/__version__.py.html docs/html/sqlobject/boundattributes.py.html docs/html/sqlobject/cache.py.html docs/html/sqlobject/classregistry.py.html docs/html/sqlobject/col.py.html docs/html/sqlobject/compat.py.html docs/html/sqlobject/constraints.py.html docs/html/sqlobject/converters.py.html docs/html/sqlobject/dbconnection.py.html docs/html/sqlobject/dberrors.py.html docs/html/sqlobject/declarative.py.html docs/html/sqlobject/events.py.html docs/html/sqlobject/index.py.html docs/html/sqlobject/joins.py.html docs/html/sqlobject/main.py.html docs/html/sqlobject/sqlbuilder.py.html docs/html/sqlobject/sresults.py.html docs/html/sqlobject/styles.py.html docs/html/sqlobject/views.py.html docs/html/sqlobject/firebird/__init__.py.html docs/html/sqlobject/include/__init__.py.html docs/html/sqlobject/inheritance/__init__.py.html docs/html/sqlobject/manager/__init__.py.html docs/html/sqlobject/maxdb/__init__.py.html docs/html/sqlobject/mssql/__init__.py.html docs/html/sqlobject/mysql/__init__.py.html docs/html/sqlobject/postgres/__init__.py.html docs/html/sqlobject/rdbhost/__init__.py.html docs/html/sqlobject/sqlite/__init__.py.html docs/html/sqlobject/sybase/__init__.py.html docs/html/sqlobject/util/__init__.py.html docs/html/sqlobject/versioning/__init__.py.html docs/presentation-2004-11/sqlobject-and-database-programming.html docs/presentation-2004-11/ui/bodybg.gif docs/presentation-2004-11/ui/custom.css docs/presentation-2004-11/ui/framing.css docs/presentation-2004-11/ui/opera.css docs/presentation-2004-11/ui/pretty.css docs/presentation-2004-11/ui/print.css docs/presentation-2004-11/ui/s5-core.css docs/presentation-2004-11/ui/slides.css docs/presentation-2004-11/ui/slides.js scripts/sqlobject-admin scripts/sqlobject-convertOldURI sqlobject/.coveragerc sqlobject/.gitignore sqlobject/__init__.py sqlobject/__version__.py sqlobject/boundattributes.py sqlobject/cache.py sqlobject/classregistry.py sqlobject/col.py sqlobject/compat.py sqlobject/conftest.py sqlobject/constraints.py sqlobject/converters.py sqlobject/dbconnection.py sqlobject/dberrors.py sqlobject/declarative.py sqlobject/events.py sqlobject/index.py sqlobject/joins.py sqlobject/main.py sqlobject/sqlbuilder.py sqlobject/sresults.py sqlobject/styles.py sqlobject/views.py sqlobject/wsgi_middleware.py sqlobject/../docs/Authors.rst sqlobject/../docs/DeveloperGuide.rst sqlobject/../docs/FAQ.rst sqlobject/../docs/Inheritance.rst sqlobject/../docs/LICENSE sqlobject/../docs/News.rst sqlobject/../docs/News1.rst sqlobject/../docs/News2.rst sqlobject/../docs/News3.rst sqlobject/../docs/News4.rst sqlobject/../docs/News5.rst sqlobject/../docs/Python3.rst sqlobject/../docs/SQLBuilder.rst sqlobject/../docs/SQLObject.rst sqlobject/../docs/SelectResults.rst sqlobject/../docs/TODO.rst sqlobject/../docs/Versioning.rst sqlobject/../docs/Views.rst sqlobject/../docs/community.rst sqlobject/../docs/default.css sqlobject/../docs/download.rst sqlobject/../docs/index.rst sqlobject/../docs/links.rst sqlobject/../docs/sqlobject-admin.rst sqlobject/../docs/html/Authors.html sqlobject/../docs/html/DeveloperGuide.html sqlobject/../docs/html/FAQ.html sqlobject/../docs/html/Inheritance.html sqlobject/../docs/html/News.html sqlobject/../docs/html/News1.html sqlobject/../docs/html/News2.html sqlobject/../docs/html/News3.html sqlobject/../docs/html/News4.html sqlobject/../docs/html/News5.html sqlobject/../docs/html/Python3.html sqlobject/../docs/html/SQLBuilder.html sqlobject/../docs/html/SQLObject.html sqlobject/../docs/html/SelectResults.html sqlobject/../docs/html/TODO.html sqlobject/../docs/html/Versioning.html sqlobject/../docs/html/Views.html sqlobject/../docs/html/class-sqlobject.boundattributes.BoundAttribute.html sqlobject/../docs/html/class-sqlobject.boundattributes.BoundFactory.html sqlobject/../docs/html/class-sqlobject.cache.CacheFactory.html sqlobject/../docs/html/class-sqlobject.cache.CacheSet.html sqlobject/../docs/html/class-sqlobject.classregistry.ClassRegistry.html sqlobject/../docs/html/class-sqlobject.col.BLOBCol.html sqlobject/../docs/html/class-sqlobject.col.BigIntCol.html sqlobject/../docs/html/class-sqlobject.col.BoolCol.html sqlobject/../docs/html/class-sqlobject.col.Col.html sqlobject/../docs/html/class-sqlobject.col.CurrencyCol.html sqlobject/../docs/html/class-sqlobject.col.DateCol.html sqlobject/../docs/html/class-sqlobject.col.DateTimeCol.html sqlobject/../docs/html/class-sqlobject.col.DecimalCol.html sqlobject/../docs/html/class-sqlobject.col.DecimalStringCol.html sqlobject/../docs/html/class-sqlobject.col.EnumCol.html sqlobject/../docs/html/class-sqlobject.col.FloatCol.html sqlobject/../docs/html/class-sqlobject.col.ForeignKey.html sqlobject/../docs/html/class-sqlobject.col.IntCol.html sqlobject/../docs/html/class-sqlobject.col.JSONCol.html sqlobject/../docs/html/class-sqlobject.col.JsonbCol.html sqlobject/../docs/html/class-sqlobject.col.KeyCol.html sqlobject/../docs/html/class-sqlobject.col.MediumIntCol.html sqlobject/../docs/html/class-sqlobject.col.PickleCol.html sqlobject/../docs/html/class-sqlobject.col.SOBLOBCol.html sqlobject/../docs/html/class-sqlobject.col.SOBigIntCol.html sqlobject/../docs/html/class-sqlobject.col.SOBoolCol.html sqlobject/../docs/html/class-sqlobject.col.SOCol.html sqlobject/../docs/html/class-sqlobject.col.SOCurrencyCol.html sqlobject/../docs/html/class-sqlobject.col.SODateCol.html sqlobject/../docs/html/class-sqlobject.col.SODateTimeCol.html sqlobject/../docs/html/class-sqlobject.col.SODecimalCol.html sqlobject/../docs/html/class-sqlobject.col.SODecimalStringCol.html sqlobject/../docs/html/class-sqlobject.col.SOEnumCol.html sqlobject/../docs/html/class-sqlobject.col.SOFloatCol.html sqlobject/../docs/html/class-sqlobject.col.SOForeignKey.html sqlobject/../docs/html/class-sqlobject.col.SOIntCol.html sqlobject/../docs/html/class-sqlobject.col.SOJSONCol.html sqlobject/../docs/html/class-sqlobject.col.SOJsonbCol.html sqlobject/../docs/html/class-sqlobject.col.SOKeyCol.html sqlobject/../docs/html/class-sqlobject.col.SOMediumIntCol.html sqlobject/../docs/html/class-sqlobject.col.SOPickleCol.html sqlobject/../docs/html/class-sqlobject.col.SOSetCol.html sqlobject/../docs/html/class-sqlobject.col.SOSmallIntCol.html sqlobject/../docs/html/class-sqlobject.col.SOStringCol.html sqlobject/../docs/html/class-sqlobject.col.SOStringLikeCol.html sqlobject/../docs/html/class-sqlobject.col.SOTimeCol.html sqlobject/../docs/html/class-sqlobject.col.SOTimedeltaCol.html sqlobject/../docs/html/class-sqlobject.col.SOTimestampCol.html sqlobject/../docs/html/class-sqlobject.col.SOTinyIntCol.html sqlobject/../docs/html/class-sqlobject.col.SOUnicodeCol.html sqlobject/../docs/html/class-sqlobject.col.SOUuidCol.html sqlobject/../docs/html/class-sqlobject.col.SetCol.html sqlobject/../docs/html/class-sqlobject.col.SmallIntCol.html sqlobject/../docs/html/class-sqlobject.col.StringCol.html sqlobject/../docs/html/class-sqlobject.col.TimeCol.html sqlobject/../docs/html/class-sqlobject.col.TimedeltaCol.html sqlobject/../docs/html/class-sqlobject.col.TimestampCol.html sqlobject/../docs/html/class-sqlobject.col.TinyIntCol.html sqlobject/../docs/html/class-sqlobject.col.UnicodeCol.html sqlobject/../docs/html/class-sqlobject.col.UuidCol.html sqlobject/../docs/html/class-sqlobject.constraints.BadValue.html sqlobject/../docs/html/class-sqlobject.constraints.InList.html sqlobject/../docs/html/class-sqlobject.constraints.MaxLength.html sqlobject/../docs/html/class-sqlobject.converters.ConverterRegistry.html sqlobject/../docs/html/class-sqlobject.dbconnection.Boolean.html sqlobject/../docs/html/class-sqlobject.dbconnection.ConnMethodWrapper.html sqlobject/../docs/html/class-sqlobject.dbconnection.ConnWrapper.html sqlobject/../docs/html/class-sqlobject.dbconnection.ConnectionHub.html sqlobject/../docs/html/class-sqlobject.dbconnection.ConnectionURIOpener.html sqlobject/../docs/html/class-sqlobject.dbconnection.ConsoleWriter.html sqlobject/../docs/html/class-sqlobject.dbconnection.DBAPI.html sqlobject/../docs/html/class-sqlobject.dbconnection.DBConnection.html sqlobject/../docs/html/class-sqlobject.dbconnection.Iteration.html sqlobject/../docs/html/class-sqlobject.dbconnection.LogWriter.html sqlobject/../docs/html/class-sqlobject.dbconnection.Transaction.html sqlobject/../docs/html/class-sqlobject.dberrors.DataError.html sqlobject/../docs/html/class-sqlobject.dberrors.DatabaseError.html sqlobject/../docs/html/class-sqlobject.dberrors.DuplicateEntryError.html sqlobject/../docs/html/class-sqlobject.dberrors.Error.html sqlobject/../docs/html/class-sqlobject.dberrors.IntegrityError.html sqlobject/../docs/html/class-sqlobject.dberrors.InterfaceError.html sqlobject/../docs/html/class-sqlobject.dberrors.InternalError.html sqlobject/../docs/html/class-sqlobject.dberrors.NotSupportedError.html sqlobject/../docs/html/class-sqlobject.dberrors.OperationalError.html sqlobject/../docs/html/class-sqlobject.dberrors.ProgrammingError.html sqlobject/../docs/html/class-sqlobject.dberrors.Warning.html sqlobject/../docs/html/class-sqlobject.declarative.Declarative.html sqlobject/../docs/html/class-sqlobject.declarative.DeclarativeMeta.html sqlobject/../docs/html/class-sqlobject.declarative.classinstancemethod.html sqlobject/../docs/html/class-sqlobject.events.AddColumnSignal.html sqlobject/../docs/html/class-sqlobject.events.ClassCreateSignal.html sqlobject/../docs/html/class-sqlobject.events.CreateTableSignal.html sqlobject/../docs/html/class-sqlobject.events.DeleteColumnSignal.html sqlobject/../docs/html/class-sqlobject.events.DropTableSignal.html sqlobject/../docs/html/class-sqlobject.events.RowCreateSignal.html sqlobject/../docs/html/class-sqlobject.events.RowCreatedSignal.html sqlobject/../docs/html/class-sqlobject.events.RowDestroySignal.html sqlobject/../docs/html/class-sqlobject.events.RowDestroyedSignal.html sqlobject/../docs/html/class-sqlobject.events.RowUpdateSignal.html sqlobject/../docs/html/class-sqlobject.events.RowUpdatedSignal.html sqlobject/../docs/html/class-sqlobject.events.Signal.html sqlobject/../docs/html/class-sqlobject.firebird.firebirdconnection.FirebirdConnection.html sqlobject/../docs/html/class-sqlobject.include.hashcol.HashCol.html sqlobject/../docs/html/class-sqlobject.include.tests.test_hashcol.HashTest.html sqlobject/../docs/html/class-sqlobject.index.DatabaseIndex.html sqlobject/../docs/html/class-sqlobject.inheritance.InheritableSQLObject.html sqlobject/../docs/html/class-sqlobject.joins.ManyToMany.html sqlobject/../docs/html/class-sqlobject.joins.MultipleJoin.html sqlobject/../docs/html/class-sqlobject.joins.OneToMany.html sqlobject/../docs/html/class-sqlobject.joins.RelatedJoin.html sqlobject/../docs/html/class-sqlobject.joins.SQLMultipleJoin.html sqlobject/../docs/html/class-sqlobject.joins.SQLRelatedJoin.html sqlobject/../docs/html/class-sqlobject.joins.SingleJoin.html sqlobject/../docs/html/class-sqlobject.main.NoDefault.html sqlobject/../docs/html/class-sqlobject.main.SQLObject.html sqlobject/../docs/html/class-sqlobject.main.SQLObjectIntegrityError.html sqlobject/../docs/html/class-sqlobject.main.SQLObjectNotFound.html sqlobject/../docs/html/class-sqlobject.main.sqlmeta.html sqlobject/../docs/html/class-sqlobject.manager.command.Command.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandCreate.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandDrop.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandExecute.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandHelp.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandList.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandRecord.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandRunner.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandSQL.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandStatus.html sqlobject/../docs/html/class-sqlobject.manager.command.CommandUpgrade.html sqlobject/../docs/html/class-sqlobject.manager.command.SQLObjectVersionTable.html sqlobject/../docs/html/class-sqlobject.maxdb.maxdbconnection.IncorrectIDStyleError.html sqlobject/../docs/html/class-sqlobject.maxdb.maxdbconnection.LowerBoundOfSliceIsNotSupported.html sqlobject/../docs/html/class-sqlobject.maxdb.maxdbconnection.MaxdbConnection.html sqlobject/../docs/html/class-sqlobject.maxdb.maxdbconnection.PrimaryKeyNotFounded.html sqlobject/../docs/html/class-sqlobject.maxdb.maxdbconnection.StyleMismatchError.html sqlobject/../docs/html/class-sqlobject.maxdb.maxdbconnection.maxdbException.html sqlobject/../docs/html/class-sqlobject.mssql.mssqlconnection.MSSQLConnection.html sqlobject/../docs/html/class-sqlobject.mysql.mysqlconnection.ErrorMessage.html sqlobject/../docs/html/class-sqlobject.mysql.mysqlconnection.MySQLConnection.html sqlobject/../docs/html/class-sqlobject.postgres.pgconnection.ErrorMessage.html sqlobject/../docs/html/class-sqlobject.postgres.pgconnection.PostgresConnection.html sqlobject/../docs/html/class-sqlobject.rdbhost.rdbhostconnection.RdbhostConnection.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Alias.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.AliasField.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.AliasTable.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.CONCAT.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.ColumnAS.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.ConstantSpace.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.DESC.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Delete.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Field.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.INSubquery.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.ImportProxy.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.ImportProxyField.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Insert.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.LIKE.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.NOTINSubquery.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.NoDefault.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Outer.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.OuterField.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.OuterTable.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.RLIKE.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Replace.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLCall.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLConstant.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLExpression.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLJoin.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLJoinConditional.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLJoinOn.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLJoinUsing.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLModulo.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLObjectField.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLObjectState.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLObjectTable.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLObjectTableWithJoins.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLOp.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLPrefix.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.SQLTrueClauseClass.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Select.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Subquery.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Table.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.TableSpace.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Union.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.Update.html sqlobject/../docs/html/class-sqlobject.sqlbuilder.VersionError.html sqlobject/../docs/html/class-sqlobject.sqlite.sqliteconnection.ErrorMessage.html sqlobject/../docs/html/class-sqlobject.sqlite.sqliteconnection.SQLiteConnection.html sqlobject/../docs/html/class-sqlobject.sresults.SelectResults.html sqlobject/../docs/html/class-sqlobject.styles.DefaultStyle.html sqlobject/../docs/html/class-sqlobject.styles.MixedCaseStyle.html sqlobject/../docs/html/class-sqlobject.styles.MixedCaseUnderscoreStyle.html sqlobject/../docs/html/class-sqlobject.styles.Style.html sqlobject/../docs/html/class-sqlobject.sybase.sybaseconnection.SybaseConnection.html sqlobject/../docs/html/class-sqlobject.versioning.Version.html sqlobject/../docs/html/class-sqlobject.versioning.Versioning.html sqlobject/../docs/html/class-sqlobject.views.ViewSQLObject.html sqlobject/../docs/html/class-sqlobject.views.ViewSQLObjectField.html sqlobject/../docs/html/class-sqlobject.views.ViewSQLObjectTable.html sqlobject/../docs/html/community.html sqlobject/../docs/html/download.html sqlobject/../docs/html/index.html sqlobject/../docs/html/layout.css sqlobject/../docs/html/links.html sqlobject/../docs/html/module-index.html sqlobject/../docs/html/module-sqlobject-index.html sqlobject/../docs/html/module-sqlobject.__version__-index.html sqlobject/../docs/html/module-sqlobject.__version__.html sqlobject/../docs/html/module-sqlobject.boundattributes-index.html sqlobject/../docs/html/module-sqlobject.boundattributes.html sqlobject/../docs/html/module-sqlobject.cache-index.html sqlobject/../docs/html/module-sqlobject.cache.html sqlobject/../docs/html/module-sqlobject.classregistry-index.html sqlobject/../docs/html/module-sqlobject.classregistry.html sqlobject/../docs/html/module-sqlobject.col-index.html sqlobject/../docs/html/module-sqlobject.col.html sqlobject/../docs/html/module-sqlobject.compat-index.html sqlobject/../docs/html/module-sqlobject.compat.html sqlobject/../docs/html/module-sqlobject.constraints-index.html sqlobject/../docs/html/module-sqlobject.constraints.html sqlobject/../docs/html/module-sqlobject.converters-index.html sqlobject/../docs/html/module-sqlobject.converters.html sqlobject/../docs/html/module-sqlobject.dbconnection-index.html sqlobject/../docs/html/module-sqlobject.dbconnection.html sqlobject/../docs/html/module-sqlobject.dberrors-index.html sqlobject/../docs/html/module-sqlobject.dberrors.html sqlobject/../docs/html/module-sqlobject.declarative-index.html sqlobject/../docs/html/module-sqlobject.declarative.html sqlobject/../docs/html/module-sqlobject.events-index.html sqlobject/../docs/html/module-sqlobject.events.html sqlobject/../docs/html/module-sqlobject.firebird-index.html sqlobject/../docs/html/module-sqlobject.firebird.firebirdconnection-index.html sqlobject/../docs/html/module-sqlobject.firebird.firebirdconnection.html sqlobject/../docs/html/module-sqlobject.firebird.html sqlobject/../docs/html/module-sqlobject.html sqlobject/../docs/html/module-sqlobject.include-index.html sqlobject/../docs/html/module-sqlobject.include.hashcol-index.html sqlobject/../docs/html/module-sqlobject.include.hashcol.html sqlobject/../docs/html/module-sqlobject.include.html sqlobject/../docs/html/module-sqlobject.include.tests-index.html sqlobject/../docs/html/module-sqlobject.include.tests.html sqlobject/../docs/html/module-sqlobject.include.tests.test_hashcol-index.html sqlobject/../docs/html/module-sqlobject.include.tests.test_hashcol.html sqlobject/../docs/html/module-sqlobject.index-index.html sqlobject/../docs/html/module-sqlobject.index.html sqlobject/../docs/html/module-sqlobject.inheritance-index.html sqlobject/../docs/html/module-sqlobject.inheritance.html sqlobject/../docs/html/module-sqlobject.joins-index.html sqlobject/../docs/html/module-sqlobject.joins.html sqlobject/../docs/html/module-sqlobject.main-index.html sqlobject/../docs/html/module-sqlobject.main.html sqlobject/../docs/html/module-sqlobject.manager-index.html sqlobject/../docs/html/module-sqlobject.manager.command-index.html sqlobject/../docs/html/module-sqlobject.manager.command.html sqlobject/../docs/html/module-sqlobject.manager.html sqlobject/../docs/html/module-sqlobject.maxdb-index.html sqlobject/../docs/html/module-sqlobject.maxdb.html sqlobject/../docs/html/module-sqlobject.maxdb.maxdbconnection-index.html sqlobject/../docs/html/module-sqlobject.maxdb.maxdbconnection.html sqlobject/../docs/html/module-sqlobject.mssql-index.html sqlobject/../docs/html/module-sqlobject.mssql.html sqlobject/../docs/html/module-sqlobject.mssql.mssqlconnection-index.html sqlobject/../docs/html/module-sqlobject.mssql.mssqlconnection.html sqlobject/../docs/html/module-sqlobject.mysql-index.html sqlobject/../docs/html/module-sqlobject.mysql.html sqlobject/../docs/html/module-sqlobject.mysql.mysqlconnection-index.html sqlobject/../docs/html/module-sqlobject.mysql.mysqlconnection.html sqlobject/../docs/html/module-sqlobject.postgres-index.html sqlobject/../docs/html/module-sqlobject.postgres.html sqlobject/../docs/html/module-sqlobject.postgres.pgconnection-index.html sqlobject/../docs/html/module-sqlobject.postgres.pgconnection.html sqlobject/../docs/html/module-sqlobject.rdbhost-index.html sqlobject/../docs/html/module-sqlobject.rdbhost.html sqlobject/../docs/html/module-sqlobject.rdbhost.rdbhostconnection-index.html sqlobject/../docs/html/module-sqlobject.rdbhost.rdbhostconnection.html sqlobject/../docs/html/module-sqlobject.sqlbuilder-index.html sqlobject/../docs/html/module-sqlobject.sqlbuilder.html sqlobject/../docs/html/module-sqlobject.sqlite-index.html sqlobject/../docs/html/module-sqlobject.sqlite.html sqlobject/../docs/html/module-sqlobject.sqlite.sqliteconnection-index.html sqlobject/../docs/html/module-sqlobject.sqlite.sqliteconnection.html sqlobject/../docs/html/module-sqlobject.sresults-index.html sqlobject/../docs/html/module-sqlobject.sresults.html sqlobject/../docs/html/module-sqlobject.styles-index.html sqlobject/../docs/html/module-sqlobject.styles.html sqlobject/../docs/html/module-sqlobject.sybase-index.html sqlobject/../docs/html/module-sqlobject.sybase.html sqlobject/../docs/html/module-sqlobject.sybase.sybaseconnection-index.html sqlobject/../docs/html/module-sqlobject.sybase.sybaseconnection.html sqlobject/../docs/html/module-sqlobject.util-index.html sqlobject/../docs/html/module-sqlobject.util.csvexport-index.html sqlobject/../docs/html/module-sqlobject.util.csvexport.html sqlobject/../docs/html/module-sqlobject.util.csvimport-index.html sqlobject/../docs/html/module-sqlobject.util.csvimport.html sqlobject/../docs/html/module-sqlobject.util.html sqlobject/../docs/html/module-sqlobject.util.moduleloader-index.html sqlobject/../docs/html/module-sqlobject.util.moduleloader.html sqlobject/../docs/html/module-sqlobject.util.threadinglocal-index.html sqlobject/../docs/html/module-sqlobject.util.threadinglocal.html sqlobject/../docs/html/module-sqlobject.versioning-index.html sqlobject/../docs/html/module-sqlobject.versioning.html sqlobject/../docs/html/module-sqlobject.views-index.html sqlobject/../docs/html/module-sqlobject.views.html sqlobject/../docs/html/pudge.css sqlobject/../docs/html/rst.css sqlobject/../docs/html/site.css sqlobject/../docs/html/sqlobject-admin.html sqlobject/../docs/html/sqlobject/__init__.py.html sqlobject/../docs/html/sqlobject/__version__.py.html sqlobject/../docs/html/sqlobject/boundattributes.py.html sqlobject/../docs/html/sqlobject/cache.py.html sqlobject/../docs/html/sqlobject/classregistry.py.html sqlobject/../docs/html/sqlobject/col.py.html sqlobject/../docs/html/sqlobject/compat.py.html sqlobject/../docs/html/sqlobject/constraints.py.html sqlobject/../docs/html/sqlobject/converters.py.html sqlobject/../docs/html/sqlobject/dbconnection.py.html sqlobject/../docs/html/sqlobject/dberrors.py.html sqlobject/../docs/html/sqlobject/declarative.py.html sqlobject/../docs/html/sqlobject/events.py.html sqlobject/../docs/html/sqlobject/index.py.html sqlobject/../docs/html/sqlobject/joins.py.html sqlobject/../docs/html/sqlobject/main.py.html sqlobject/../docs/html/sqlobject/sqlbuilder.py.html sqlobject/../docs/html/sqlobject/sresults.py.html sqlobject/../docs/html/sqlobject/styles.py.html sqlobject/../docs/html/sqlobject/views.py.html sqlobject/../docs/html/sqlobject/firebird/__init__.py.html sqlobject/../docs/html/sqlobject/include/__init__.py.html sqlobject/../docs/html/sqlobject/inheritance/__init__.py.html sqlobject/../docs/html/sqlobject/manager/__init__.py.html sqlobject/../docs/html/sqlobject/maxdb/__init__.py.html sqlobject/../docs/html/sqlobject/mssql/__init__.py.html sqlobject/../docs/html/sqlobject/mysql/__init__.py.html sqlobject/../docs/html/sqlobject/postgres/__init__.py.html sqlobject/../docs/html/sqlobject/rdbhost/__init__.py.html sqlobject/../docs/html/sqlobject/sqlite/__init__.py.html sqlobject/../docs/html/sqlobject/sybase/__init__.py.html sqlobject/../docs/html/sqlobject/util/__init__.py.html sqlobject/../docs/html/sqlobject/versioning/__init__.py.html sqlobject/firebird/__init__.py sqlobject/firebird/firebirdconnection.py sqlobject/include/__init__.py sqlobject/include/hashcol.py sqlobject/include/tests/__init__.py sqlobject/include/tests/test_hashcol.py sqlobject/inheritance/__init__.py sqlobject/inheritance/iteration.py sqlobject/inheritance/tests/__init__.py sqlobject/inheritance/tests/testDestroyCascade.py sqlobject/inheritance/tests/test_aggregates.py sqlobject/inheritance/tests/test_asdict.py sqlobject/inheritance/tests/test_deep_inheritance.py sqlobject/inheritance/tests/test_foreignKey.py sqlobject/inheritance/tests/test_indexes.py sqlobject/inheritance/tests/test_inheritance.py sqlobject/inheritance/tests/test_inheritance_tree.py sqlobject/manager/__init__.py sqlobject/manager/command.py sqlobject/maxdb/__init__.py sqlobject/maxdb/maxdbconnection.py sqlobject/maxdb/readme.txt sqlobject/mssql/__init__.py sqlobject/mssql/mssqlconnection.py sqlobject/mysql/__init__.py sqlobject/mysql/mysqlconnection.py sqlobject/postgres/__init__.py sqlobject/postgres/pgconnection.py sqlobject/rdbhost/__init__.py sqlobject/rdbhost/rdbhostconnection.py sqlobject/sqlite/__init__.py sqlobject/sqlite/sqliteconnection.py sqlobject/sybase/__init__.py sqlobject/sybase/sybaseconnection.py sqlobject/tests/__init__.py sqlobject/tests/dbtest.py sqlobject/tests/test_ForeignKey.py sqlobject/tests/test_NoneValuedResultItem.py sqlobject/tests/test_SQLMultipleJoin.py sqlobject/tests/test_SQLRelatedJoin.py sqlobject/tests/test_SingleJoin.py sqlobject/tests/test_aggregates.py sqlobject/tests/test_aliases.py sqlobject/tests/test_asdict.py sqlobject/tests/test_auto.py sqlobject/tests/test_basic.py sqlobject/tests/test_blob.py sqlobject/tests/test_boundattributes.py sqlobject/tests/test_cache.py sqlobject/tests/test_class_hash.py sqlobject/tests/test_columns_order.py sqlobject/tests/test_combining_joins.py sqlobject/tests/test_comparison.py sqlobject/tests/test_complex_sorting.py sqlobject/tests/test_constraints.py sqlobject/tests/test_converters.py sqlobject/tests/test_create_drop.py sqlobject/tests/test_csvexport.py sqlobject/tests/test_cyclic_reference.py sqlobject/tests/test_datetime.py sqlobject/tests/test_decimal.py sqlobject/tests/test_declarative.py sqlobject/tests/test_default_style.py sqlobject/tests/test_delete.py sqlobject/tests/test_distinct.py sqlobject/tests/test_empty.py sqlobject/tests/test_enum.py sqlobject/tests/test_events.py sqlobject/tests/test_exceptions.py sqlobject/tests/test_expire.py sqlobject/tests/test_groupBy.py sqlobject/tests/test_identity.py sqlobject/tests/test_indexes.py sqlobject/tests/test_inheritance.py sqlobject/tests/test_joins.py sqlobject/tests/test_joins_conditional.py sqlobject/tests/test_jsonbcol.py sqlobject/tests/test_jsoncol.py sqlobject/tests/test_lazy.py sqlobject/tests/test_md5.py sqlobject/tests/test_mysql.py sqlobject/tests/test_new_joins.py sqlobject/tests/test_parse_uri.py sqlobject/tests/test_paste.py sqlobject/tests/test_perConnection.py sqlobject/tests/test_pickle.py sqlobject/tests/test_picklecol.py sqlobject/tests/test_postgres.py sqlobject/tests/test_reparent_sqlmeta.py sqlobject/tests/test_schema.py sqlobject/tests/test_select.py sqlobject/tests/test_select_through.py sqlobject/tests/test_setters.py sqlobject/tests/test_slice.py sqlobject/tests/test_sorting.py sqlobject/tests/test_sqlbuilder.py sqlobject/tests/test_sqlbuilder_dbspecific.py sqlobject/tests/test_sqlbuilder_importproxy.py sqlobject/tests/test_sqlbuilder_joins_instances.py sqlobject/tests/test_sqlite.py sqlobject/tests/test_sqlmeta_idName.py sqlobject/tests/test_sqlobject_admin.py sqlobject/tests/test_string_id.py sqlobject/tests/test_style.py sqlobject/tests/test_subqueries.py sqlobject/tests/test_transactions.py sqlobject/tests/test_unicode.py sqlobject/tests/test_uuidcol.py sqlobject/tests/test_validation.py sqlobject/tests/test_views.py sqlobject/util/__init__.py sqlobject/util/csvexport.py sqlobject/util/csvimport.py sqlobject/util/moduleloader.py sqlobject/util/threadinglocal.py sqlobject/versioning/__init__.py sqlobject/versioning/test/__init__.py sqlobject/versioning/test/test_version.pySQLObject-3.1.0/SQLObject.egg-info/top_level.txt0000644000175000017500000000001212754657355020677 0ustar phdphd00000000000000sqlobject SQLObject-3.1.0/SQLObject.egg-info/requires.txt0000644000175000017500000000025212754657355020553 0ustar phdphd00000000000000FormEncode>=1.1.1,!=1.3.0 PyDispatcher>=2.0.4 [firebird] fdb [mssql] adodbapi [mysql] MySQLdb [postgresql] psycopg [sapdb] sapdb [sqlite] pysqlite [sybase] Sybase SQLObject-3.1.0/SQLObject.egg-info/PKG-INFO0000644000175000017500000000343712754657355017260 0ustar phdphd00000000000000Metadata-Version: 1.1 Name: SQLObject Version: 3.1.0 Summary: Object-Relational Manager, aka database wrapper Home-page: http://sqlobject.org/devel/ Author: Oleg Broytman Author-email: phd@phdru.name License: LGPL Download-URL: https://pypi.python.org/pypi/SQLObject/3.1.0 Description: SQLObject is a popular *Object Relational Manager* for providing an object interface to your database, with tables as classes, rows as instances, and columns as attributes. SQLObject includes a Python-object-based query language that makes SQL more abstract, and provides substantial database independence for applications. Supports MySQL, PostgreSQL, SQLite, Firebird, Sybase, MSSQL and MaxDB (SAPDB). Python 2.6, 2.7 or 3.4+ is required. For development see the projects at `SourceForge `_ and `GitHub `_. .. image:: https://travis-ci.org/sqlobject/sqlobject.svg?branch=master :target: https://travis-ci.org/sqlobject/sqlobject Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.4 Classifier: Topic :: Database Classifier: Topic :: Database :: Front-Ends Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires: FormEncode Requires: PyDispatcher SQLObject-3.1.0/.gitignore0000644000175000017500000000011412364236145014643 0ustar phdphd00000000000000*~ *.tmp *.pyc *.pyo /MANIFEST /SQLObject.egg-info /build /data /dist /temp SQLObject-3.1.0/requirements_dev.txt0000644000175000017500000000006212751734124016777 0ustar phdphd00000000000000-r requirements.txt pytest pytest-cov tox >= 1.8 SQLObject-3.1.0/setup.py0000755000175000017500000001403012754656750014405 0ustar phdphd00000000000000#!/usr/bin/env python import sys from imp import load_source from os.path import abspath, dirname, join try: from ez_setup import use_setuptools use_setuptools() from setuptools import setup is_setuptools = True except ImportError: from distutils.core import setup is_setuptools = False versionpath = join(abspath(dirname(__file__)), "sqlobject", "__version__.py") load_source("sqlobject_version", versionpath) from sqlobject_version import version # noqa: ignore flake8 E402 subpackages = ['firebird', 'include', 'include.tests', 'inheritance', 'inheritance.tests', 'manager', 'maxdb', 'mysql', 'mssql', 'postgres', 'rdbhost', 'sqlite', 'sybase', 'tests', 'util', 'versioning', 'versioning.test'] kw = {} if is_setuptools: kw['entry_points'] = """ [paste.filter_app_factory] main = sqlobject.wsgi_middleware:make_middleware """ install_requires = [] if (sys.version_info[0] == 2) and (sys.version_info[:2] >= (2, 6)): install_requires.append("FormEncode>=1.1.1,!=1.3.0") elif (sys.version_info[0] == 3) and (sys.version_info[:2] >= (3, 4)): install_requires.append("FormEncode>=1.3.1") else: raise ImportError("SQLObject requires Python 2.6, 2.7 or 3.4+") install_requires.append("PyDispatcher>=2.0.4") kw['install_requires'] = install_requires kw['extras_require'] = { 'mysql': ['MySQLdb'], 'postgresql': ['psycopg'], # or pgdb from PyGreSQL 'sqlite': ['pysqlite'], 'firebird': ['fdb'], # or kinterbasdb 'sybase': ['Sybase'], 'mssql': ['adodbapi'], # or pymssql 'sapdb': ['sapdb'], } setup(name="SQLObject", version=version, description="Object-Relational Manager, aka database wrapper", long_description="""\ SQLObject is a popular *Object Relational Manager* for providing an object interface to your database, with tables as classes, rows as instances, and columns as attributes. SQLObject includes a Python-object-based query language that makes SQL more abstract, and provides substantial database independence for applications. Supports MySQL, PostgreSQL, SQLite, Firebird, Sybase, MSSQL and MaxDB (SAPDB). Python 2.6, 2.7 or 3.4+ is required. For development see the projects at `SourceForge `_ and `GitHub `_. .. image:: https://travis-ci.org/sqlobject/sqlobject.svg?branch=master :target: https://travis-ci.org/sqlobject/sqlobject """, classifiers=[ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: " "GNU Library or Lesser General Public License (LGPL)", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.4", "Topic :: Database", "Topic :: Database :: Front-Ends", "Topic :: Software Development :: Libraries :: Python Modules", ], author="Ian Bicking", author_email="ianb@colorstudy.com", maintainer="Oleg Broytman", maintainer_email="phd@phdru.name", url="http://sqlobject.org/devel/", download_url="https://pypi.python.org/pypi/SQLObject/%s" % version, license="LGPL", packages=["sqlobject"] + ['sqlobject.%s' % package for package in subpackages], scripts=["scripts/sqlobject-admin", "scripts/sqlobject-convertOldURI"], package_data={"sqlobject": [ "../docs/LICENSE", "../docs/*.rst", "../docs/*.css", "../docs/html/*.html", "../docs/html/*.css", "../docs/html/sqlobject/*.html", "../docs/html/sqlobject/firebird/*.html", "../docs/html/sqlobject/include/*.html", "../docs/html/sqlobject/inheritance/*.html", "../docs/html/sqlobject/manager/*.html", "../docs/html/sqlobject/maxdb/*.html", "../docs/html/sqlobject/mssql/*.html", "../docs/html/sqlobject/mysql/*.html", "../docs/html/sqlobject/postgres/*.html", "../docs/html/sqlobject/rdbhost/*.html", "../docs/html/sqlobject/sqlite/*.html", "../docs/html/sqlobject/sybase/*.html", "../docs/html/sqlobject/util/*.html", "../docs/html/sqlobject/versioning/*.html", ], "sqlobject.maxdb": ["readme.txt"], }, requires=['FormEncode', 'PyDispatcher'], **kw ) # Send announce to: # sqlobject-discuss@lists.sourceforge.net # python-announce@python.org # python-list@python.org # db-sig@python.org # Email tempate: """ @@ INTRO What's new in SQLObject ======================= @@ CHANGES For a more complete list, please see the news: http://sqlobject.org/docs/News.html What is SQLObject ================= SQLObject is an object-relational mapper. Your database tables are described as classes, and rows are instances of those classes. SQLObject is meant to be easy to use and quick to get started with. It currently supports MySQL through the `MySQLdb` package, PostgreSQL through the `psycopg` package, SQLite, Firebird, MaxDB (SAP DB), MS SQL Sybase and Rdbhost. Python 2.6, 2.7 or 3.4+ is required. Where is SQLObject ================== Site: http://sqlobject.org Mailing list: https://lists.sourceforge.net/mailman/listinfo/sqlobject-discuss Archives: http://news.gmane.org/gmane.comp.python.sqlobject Download: https://pypi.python.org/pypi/SQLObject/@@ News and changes: http://sqlobject.org/docs/News.html -- Ian Bicking / ianb@colorstudy.com / http://blog.ianbicking.org """ # noqa: preserve space after two dashes SQLObject-3.1.0/docs/0000755000175000017500000000000012754657361013621 5ustar phdphd00000000000000SQLObject-3.1.0/docs/TODO.rst0000644000175000017500000001005012752476767015123 0ustar phdphd00000000000000TODO ---- * RelatedJoin.hasOther(otherObject[.id]) * createParamsPre/Post:: class MyTable(SQLObject): class sqlmeta: createParamsPre = 'TEMPORARY IF NOT EXISTS' createParamsPre = {temporary: True, ifNotExists: True, 'postgres': 'LOCAL'} createParamsPost = 'ENGINE InnoDB' createParamsPost = {'mysql': 'ENGINE InnoDB', 'postgres': 'WITH OIDS'} * SQLObject.fastInsert(). * IntervalCol * TimedeltaCol * Cached join results. * Invert tests isinstance(obj, (tuple, list)) to not isinstance(obj, basestr) to allow any iterable. * Always use .lazyIter(). * Optimize Iteration.next() - use cursor.fetchmany(). * Generators instead of loops (fetchall => fetchone). * Cache columns in sqlmeta.getColumns(); reset the cache on add/del Column/Join. * Make ConnectionHub a context manager instead of .doInTransaction(). * Make version_info a namedtuple. * Expression columns - in SELECT but not in INSERT/UPDATE. Something like this:: class MyClass(SQLObject): function1 = ExpressionCol(func.my_function(MyClass.q.col1)) function2 = ExpressionCol('sum(col2)') * A hierarchy of exceptions. SQLObject should translate exceptions from low-level drivers to a consistent set of high-level exceptions. * Memcache. * Refactor ``DBConnection`` to use parameterized queries instead of generating query strings. * PREPARE/EXECUTE. * Protect all .encode(), catch UnicodeEncode exceptions and reraise Invalid. * More kinds of joins, and more powerful join results (closer to how `select` works). * Better joins - automatic joins in .select() based on ForeignKey/MultipleJoin/RelatedJoin. * Deprecate, then remove connectionForOldURI. * Switch from setuptools to distribute. * oursql MySQL bindings: https://github.com/python-oursql/oursql * MySQL Connector/Python: https://dev.mysql.com/doc/connector-python/en/ * Pure Python Mysql Interface: https://github.com/nasi/MyPy * pg8000 driver: http://code.google.com/p/pg8000/ * py-postgresql driver: http://python.projects.postgresql.org/ * pyfirebirdsql: https://github.com/nakagami/pyfirebirdsql * dict API: use getitem interface for column access instead of getattr; reserve getattr for internal attributes only; this helps to avoid collisions with internal attributes. * Or move column values access to a separate namespace, e.g. .c: row.c.column. * More documentation. * RSS 2.0 and Atom news feeds. * Use DBUtils_, especially SolidConnection. .. _DBUtils: http://www.webwareforpython.org/DBUtils * ``_fromDatabase`` currently doesn't support IDs that don't fit into the normal naming scheme. It should do so. You can still use ``_idName`` with ``_fromDatabase``. * More databases supported. There has been interest and some work in the progress for Oracle. IWBN to have Informix and DB2 drivers. * Better transaction support -- right now you can use transactions for the database, but objects aren't transaction-aware, so non-database persistence won't be able to be rolled back. * Optimistic locking and other techniques to handle concurrency. * Profile of SQLObject performance to identify bottlenecks. * Increase hooks with FormEncode validation and form generation package, so SQLObject classes (read: schemas) can be published for editing more directly and easily. (First step: get Schema-generating method into sqlmeta class) * Merge SQLObject.create*, .create*SQL methods with DBPI.create* methods. * Made SQLObject unicode-based instead of just unicode-aware. All internal processing should be done with unicode strings, conversion to/from ascii strings should happen for non-unicode DB API drivers. * Allow to override ConsoleWriter/LogWriter classes and makeDebugWriter function. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/links.rst0000644000175000017500000000354112753243417015466 0ustar phdphd00000000000000SQLObject Links =============== .. contents:: If you have a link you'd like added to this page, please submit a bug report with the link and title at `bug tracker `_ or send pull requests at `GitHub `_). Articles and Documentation -------------------------- * `Connecting databases to Python with SQLObject `_; an article at DeveloperWorks. * `DB migration using sqlobject-admin how-to `_. * `Using raw SQL with SQLObject and keeping the object-y goodness `_. * `Example of using SQLObject with web.py under mod_wsgi `_. Open Source Projects -------------------- * `TurboGears `_ Web Framework: also integrates with SQLObject. * `Catwalk `_ is a web-based SQLObject browser and object editor (included in TurboGears). * `Ultra Gleeper `_, a Recommendation Engine for Web Pages. * `Guten `_; an application for browsing, reading, and managing books from `Project Gutenberg `_. * `My Newspaper `_, a personal RSS Aggregator and Reader. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/FAQ.rst0000644000175000017500000005072512752476767015002 0ustar phdphd00000000000000+++++++++++++ SQLObject FAQ +++++++++++++ .. contents:: SQLExpression ------------- In `SomeTable.select(SomeTable.q.Foo > 30)` why doesn't the inner parameter, `SomeTable.q.Foo > 30`, get evaluated to some boolean value? `q` is an object that returns special attributes of type `sqlbuilder.SQLExpression`. SQLExpression is a special class that overrides almost all Python magic methods and upon any operation instead of evaluating it constructs another instance of SQLExpression that remembers what operation it has to do. Similar to a symbolic algebra. Example: SQLExpression("foo") > 30 produces SQLExpression("foo", ">", 30) (well, it really produces SQLExpression(SQLExpression("foo")...)) How does the select(...) method know what to do? ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In short, select() recursively evaluates the top-most SQLExpression to a string: SQLExpression("foo", ">", 30) => "foo > 30" and passes the result as a string to the SQL backend. The longer but more detailed and correct explanation is that select() produces an instance of SelectResults_ class that upon being iterated over produces an instance of Iteration class that upon calling its next() method (it is iterator!) construct the SQL query string, passes it to the backend, fetches the results, wraps every row as SQLObject instance and passes them back to the user. .. _SelectResults: SelectResults.html For the details of the implementation see sqlobject/main.py for SQLObject, sqlobject/sqlbuilder.py for SQLExpression, sqlobject/dbconnection.py for DBConnection class (that constructs the query strings) and Iteration class, and different subdirectories of sqlobject for concrete implementations of connection classes - different backends require different query strings. Why there is no __len__? ------------------------ There are reasons why there is no __len__ method, though many people think having those make them feel more integrated into Python. One is that len(foo) is expected to be fast, but issuing a COUNT query can be slow. Worse, often this causes the database to do essentially redundant work when the actual query is performed (generally taking the len of a sequence is followed by accessing items from that sequence). Another is that list(foo) implicitly tries to do a len first, as an optimization (because len is expected to be cheap -- see previous point). Worse, it swallows *all* exceptions that occur during that call to __len__, so if it fails (e.g. there's a typo somewhere in the query), the original cause is silently discarded, and instead you're left with mysterious errors like "current transaction is aborted, commands ignored until end of transaction block" for no apparent reason. How can I do a LEFT JOIN? ------------------------- The short: you can't. You don't need to. That's a relational way of thinking, not an object way of thinking. But it's okay! It's not hard to do the same thing, even if it's not with the same query. For these examples, imagine you have a bunch of customers, with contacts. Not all customers have a contact, some have several. The left join would look like:: SELECT customer.id, customer.first_name, customer.last_name, contact.id, contact.address FROM customer LEFT JOIN contact ON contact.customer_id = customer.id Simple ~~~~~~ :: for customer in Customer.select(): print customer.firstName, customer.lastName for contact in customer.contacts: print ' ', contact.phoneNumber The effect is the same as the left join -- you get all the customers, and you get all their contacts. The problem, however, is that you will be executing more queries -- a query for each customer to fetch the contacts -- where with the left join you'd only do one query. The actual amount of information returned from the database will be the same. There's a good chance that this won't be significantly slower. I'd advise doing it this way unless you hit an actual performance problem. Efficient ~~~~~~~~~ Lets say you really don't want to do all those queries. Okay, fine:: custContacts = {} for contact in Contact.select(): custContacts.setdefault(contact.customerID, []).append(contact) for customer in Customer.select(): print customer.firstName, customer.lastName for contact in custContacts.get(customer.id, []): print ' ', contact.phoneNumber This way there will only be at most two queries. It's a little more crude, but this is an optimization, and optimizations often look less than pretty. But, say you don't want to get everyone, just some group of people (presumably a large enough group that you still need this optimization):: query = Customer.q.firstName.startswith('J') custContacts = {} for contact in Contact.select(AND(Contact.q.customerID == Customer.q.id, query)): custContacts.setdefault(contact.customerID, []).append(contact) for customer in Customer.select(query): print customer.firstName, customer.lastName for contact in custContacts.get(customer.id, []): print ' ', contact.phoneNumber SQL-wise ~~~~~~~~ Use LEFTJOIN() from SQLBuilder_. How can I join a table with itself? ----------------------------------- Use Alias from SQLBuilder_. See example_. .. _SQLBuilder: SQLBuilder.html .. _example: SQLObject.html#how-can-i-join-a-table-with-itself How can I define my own intermediate table in my Many-to-Many relationship? --------------------------------------------------------------------------- .. note:: In User and Role, SQLRelatedJoin is used with createRelatedTable=False so the intermediate table is not created automatically. We also set the intermediate table name with intermediateTable='user_roles'. UserRoles is the definition of our intermediate table. UserRoles creates a unique index to make sure we don't have duplicate data in the database. We also added an extra field called active which has a boolean value. The active column might be used to activate/deactivate a given role for a user in this example. Another common field to add in this an intermediate table might be a sort field. If you want to get a list of rows from the intermediate table directly add a MultipleJoin to User or Role class. We'll expand on the User and Role example and define our own UserRoles class which will be the intermediate table for the User and Role Many-to-Many relationship. Example:: >>> class User(SQLObject): ... class sqlmeta: ... table = "user_table" ... username = StringCol(alternateID=True, length=20) ... roles = SQLRelatedJoin('Role', ... intermediateTable='user_roles', ... createRelatedTable=False) >>> class Role(SQLObject): ... name = StringCol(alternateID=True, length=20) ... users = SQLRelatedJoin('User', ... intermediateTable='user_roles', ... createRelatedTable=False) >>> class UserRoles(SQLObject): ... class sqlmeta: ... table = "user_roles" ... user = ForeignKey('User', notNull=True, cascade=True) ... role = ForeignKey('Role', notNull=True, cascade=True) ... active = BoolCol(notNull=True, default=False) ... unique = index.DatabaseIndex(user, role, unique=True) How Does Inheritance Work? -------------------------- SQLObject is not intended to represent every Python inheritance structure in an RDBMS -- rather it is intended to represent RDBMS structures as Python objects. So lots of things you can do in Python you can't do with SQLObject classes. However, some form of inheritance is possible. One way of using this is to create local conventions. Perhaps:: class SiteSQLObject(SQLObject): _connection = DBConnection.MySQLConnection(user='test', db='test') _style = MixedCaseStyle() # And maybe you want a list of the columns, to autogenerate # forms from: def columns(self): return [col.name for col in self._columns] Since SQLObject doesn't have a firm introspection mechanism (at least not yet) the example shows the beginnings of a bit of ad hoc introspection (in this case exposing the ``_columns`` attribute in a more pleasing/public interface). However, this doesn't relate to *database* inheritance at all, since we didn't define any columns. What if we do? :: class Person(SQLObject): firstName = StringCol() lastName = StringCol() class Employee(Person): position = StringCol() Unfortunately, the resultant schema probably doesn't look like what you might have wanted:: CREATE TABLE person ( id INT PRIMARY KEY, first_name TEXT, last_name TEXT ); CREATE TABLE employee ( id INT PRIMARY KEY first_name TEXT, last_name TEXT, position TEXT ) All the columns from ``person`` are just repeated in the ``employee`` table. What's more, an ID for a Person is distinct from an ID for an employee, so for instance you must choose ``ForeignKey("Person")`` or ``ForeignKey("Employee")``, you can't have a foreign key that sometimes refers to one, and sometimes refers to the other. Altogether, not very useful. You probably want a ``person`` table, and then an ``employee`` table with a one-to-one relation between the two. Of course, you can have that, just create the appropriate classes/tables -- but it will appear as two distinct classes, and you'd have to do something like ``Person(1).employee.position``. Of course, you can always create the necessary shortcuts, like:: class Person(SQLObject): firstName = StringCol() lastName = StringCol() def _get_employee(self): value = Employee.selectBy(person=self) if value: return value[0] else: raise AttributeError, '%r is not an employee' % self def _get_isEmployee(self): value = Employee.selectBy(person=self) # turn into a bool: return not not value def _set_isEmployee(self, value): if value: # Make sure we are an employee... if not self.isEmployee: Empoyee.new(person=self, position=None) else: if self.isEmployee: self.employee.destroySelf() def _get_position(self): return self.employee.position def _set_position(self, value): self.employee.position = value class Employee(SQLObject): person = ForeignKey('Person') position = StringCol() There is also another kind of inheritance. See Inheritance.html_ .. _Inheritance.html: Inheritance.html Composite/Compound Attributes ----------------------------- A composite attribute is an attribute formed from two columns. For example:: CREATE TABLE invoice_item ( id INT PRIMARY KEY, amount NUMERIC(10, 2), currency CHAR(3) ); Now, you'll probably want to deal with one amount/currency value, instead of two columns. SQLObject doesn't directly support this, but it's easy (and encouraged) to do it on your own:: class InvoiceItem(SQLObject): amount = Currency() currency = StringChar(length=3) def _get_price(self): return Price(self.amount, self.currency) def _set_price(self, price): self.amount = price.amount self.currency = price.currency class Price(object): def __init__(self, amount, currency): self._amount = amount self._currency = currency def _get_amount(self): return self._amount amount = property(_get_amount) def _get_currency(self): return self._currency currency = property(_get_currency) def __repr__(self): return '' % (self.amount, self.currency) You'll note we go to some trouble to make sure that ``Price`` is an immutable object. This is important, because if ``Price`` wasn't and someone changed an attribute, the containing ``InvoiceItem`` instance wouldn't detect the change and update the database. (Also, since ``Price`` doesn't subclass ``SQLObject``, we have to be explicit about creating properties) Some people refer to this sort of class as a *Value Object*, that can be used similar to how an integer or string is used. You could also use a mutable composite class:: class Address(SQLObject): street = StringCol() city = StringCol() state = StringCol(length=2) latitude = FloatCol() longitude = FloatCol() def _init(self, id): SQLObject._init(self, id) self._coords = SOCoords(self) def _get_coords(self): return self._coords class SOCoords(object): def __init__(self, so): self._so = so def _get_latitude(self): return self._so.latitude def _set_latitude(self, value): self._so.latitude = value latitude = property(_get_latitude, set_latitude) def _get_longitude(self): return self._so.longitude def _set_longitude(self, value): self._so.longitude = value longitude = property(_get_longitude, set_longitude) Pretty much a proxy, really, but ``SOCoords`` could contain other logic, could interact with non-SQLObject-based latitude/longitude values, or could be used among several objects that have latitude/longitude columns. Non-Integer IDs --------------- Yes, you can use non-integer IDs. If you use non-integer IDs, you will not be able to use automatic ``CREATE TABLE`` generation (i.e., ``createTable``); SQLObject can create tables with int or str IDs. You also will have to give your own ID values when creating an object, like:: color = Something(id="blue", r=0, b=100, g=0) IDs are, and always will in future versions, be considered immutable. Right now that is not enforced; you can assign to the ``id`` attribute. But if you do you'll just mess everything up. This will probably be taken away sometime to avoid possibly confusing bugs (actually, assigning to ``id`` is almost certain to cause confusing bugs). If you are concerned about enforcing the type of IDs (which can be a problem even with integer IDs) you may want to do this:: def Color(SQLObject): def _init(self, id, connection=None): id = str(id) SQLObject._init(self, id, connection) Instead of ``str()`` you may use ``int()`` or whatever else you want. This will be resolved in a future version when ID column types can be declared like other columns. Additionally you can set idType=str in you SQLObject class. Binary Values ------------- Binary values can be difficult to store in databases, as SQL doesn't have a widely-implemented way to express binaries as literals, and there's differing support in database. The module sqlobject.col defines validators and column classes that to some extent support binary values. There is BLOBCol that extends StringCol and allow to store binary values; currently it works only with PostgreSQL and MySQL. PickleCol extends BLOBCol and allows to store any object in the column; the column, naturally, pickles the object upon assignment and unpickles it upon retrieving the data from the DB. Another possible way to keep binary data in a database is by using encoding. Base 64 is a good encoding, reasonably compact but also safe. As an example, imagine you want to store images in the database:: class Image(SQLObject): data = StringCol() height = IntCol() width = IntCol() def _set_data(self, value): self._SO_set_data(value.encode('base64')) def _get_data(self, value): return self._SO_get_data().decode('base64') Reloading Modules ----------------- If you've tried to reload a module that defines SQLObject subclasses, you've probably encountered various odd errors. The short answer: you can't reload these modules. The long answer: reloading modules in Python doesn't work very well. Reloading actually means *re-running* the module. Every ``class`` statement creates a class -- but your old classes don't disappear. When you reload a module, new classes are created, and they take over the names in the module. SQLObject, however, doesn't search the names in a module to find a class. When you say ``ForeignKey('SomeClass')``, SQLObject looks for any SQLObject subclass anywhere with the name ``SomeClass``. This is to avoid problems with circular imports and circular dependencies, as tables have forward- and back-references, and other circular dependencies. SQLObject resolves these dependencies lazily. But when you reload a module, suddenly there will be two SQLObject classes in the process with the same name. SQLObject doesn't know that one of them is obsolete. And even if it did, it doesn't know every other place in the system that has a reference to that obsolete class. For this reason and several others, reloading modules is highly error-prone and difficult to support. Python Keywords --------------- If you have a table column that is a Python keyword, you should know that the Python attribute doesn't have to match the name of the column. See `Irregular Naming`_ in the documentation. .. _Irregular Naming: SQLObject.html#irregular-naming Lazy Updates and Insert ----------------------- `Lazy updates `_ allow you to defer sending ``UPDATES`` until you synchronize the object. However, there is no way to do a lazy insert; as soon as you create an instance the ``INSERT`` is executed. The reason for this limit is that each object needs a database ID, and in many databases you cannot attain an ID until you create a row. Mutually referencing tables --------------------------- How can I create mutually referencing tables? For the code:: class Person(SQLObject): role = ForeignKey("Role") class Role(SQLObject): person = ForeignKey("Person") Person.createTable() Role.createTable() Postgres raises ProgrammingError: ERROR: relation "role" does not exist. The correct way is to delay constraints creation until all tables are created:: class Person(SQLObject): role = ForeignKey("Role") class Role(SQLObject): person = ForeignKey("Person") constraints = Person.createTable(applyConstraints=False) constraints += Role.createTable(applyConstraints=False) for constraint in constraints: connection.query(constraint) What about GROUP BY, UNION, etc? -------------------------------- In short - not every query can be represented in SQLObject. SQLOBject's objects are instances of "table" clasess:: class MyTable(SQLObject): ... my_table_row = MyTable.get(id) Now my_table_row is an instance of MyTable class and represents a row in the my_table table. But for a statement with GROUP BY like this:: SELECT my_column, COUNT(*) FROM my_table GROUP BY my_column; there is no table, there is no corresponding "table" class, and SQLObject cannot return a list of meaningful objects. You can use a lower-level machinery available in SQLBuilder_. How to do mass-insertion? ------------------------- Mass-insertion using high-level API in SQLObject is slow. There are many reasons for that. First, on creation SQLObject instances pass all values through validators/converters which is convenient but takes time. Second, after an INSERT query SQLObject executes a SELECT query to get back autogenerated values (id and timestamps). Third, there is caching and cache maintaining. Most of this is unnecessary for mass-insertion, hence high-level API is unsuitable. Less convenient (no validators) but much faster API is Insert_ from SQLBuilder_. .. _Insert: SQLBuilder.html#insert How can I specify the MySQL engine to use, or tweak other SQL-engine specific features? --------------------------------------------------------------------------------------- You can *ALTER* the table just after creation using the ``sqlmeta`` attribute ``createSQL``, for example:: class SomeObject(SQLObject): class sqlmeta: createSQL = { 'mysql' : 'ALTER TABLE some_object ENGINE InnoDB' } # your columns here Maybe you want to specify the charset too? No problem:: class SomeObject(SQLObject): class sqlmeta: createSQL = { 'mysql' : [ 'ALTER TABLE some_object ENGINE InnoDB', '''ALTER TABLE some_object CHARACTER SET utf8 COLLATE utf8_estonian_ci'''] } .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/interface.py0000644000175000017500000002672012461505074016126 0ustar phdphd00000000000000""" This is a not-very-formal outline of the interface that SQLObject provides. While its in the form of a formal interface, it doesn't use any interface system. """ class Interface(object): pass class ISQLObject(Interface): sqlmeta = """ A class or instance representing internal state and methods for introspecting this class. ``MyClass.sqlmeta`` is a class, and ``myInstance.sqlmeta`` is an instance of this class. So every instance gets its own instance of the metadata. This object follows the ``Isqlmeta`` interface. """ # classmethod def get(id, connection=None): """ Returns the object with the given `id`. If `connection` is given, then get the object from the given connection (otherwise use the default or configured connection) It raises ``SQLObjectNotFound`` if no row exists with that ID. """ # classmethod def selectBy(connection=None, **attrs): """ Performs a ``SELECT`` in the given `connection` (or default connection). Each of the keyword arguments should be a column, and the equality comparisons will be ``ANDed`` together to produce the result. """ # classmethod def dropTable(ifExists=False, dropJoinTables=True, cascade=False, connection=None): """ Drops this table from the database. If ``ifExists`` is true, then it is not an error if the table doesn't exist. Join tables (mapping tables for many-to-many joins) are dropped if this class comes alphabetically before the other join class, and if ``dropJoinTables`` is true. ``cascade`` is passed to the connection, and if true tries to drop tables that depend on this table. """ # classmethod def createTable(ifNotExists=False, createJoinTables=True, createIndexes=True, connection=None): """ Creates the table. If ``ifNotExists`` is true, then it is not an error if the table already exists. Join tables (mapping tables for many-to-many joins) are created if this class comes alphabetically before the other join class, and if ``createJoinTables`` is true. If ``createIndexes`` is true, indexes are also created. """ # classmethod def createTableSQL(createJoinTables=True, connection=None, createIndexes=True): """ Returns the SQL that would be sent with the analogous call to ``Class.createTable(...)`` """ def sync(): """ This will refetch the data from the database, putting it in sync with the database (in case another process has modified the database since this object was fetched). It will raise ``SQLObjectNotFound`` if the row has been deleted. This will call ``self.syncUpdate()`` if ``lazyUpdates`` are on. """ def syncUpdate(): """ If ``.sqlmeta.lazyUpdates`` is true, then this method must be called to push accumulated updates to the server. """ def expire(): """ This will remove all the column information from the object. The next time this information is used, a ``SELECT`` will be made to re-fetch the data. This is like a lazy ``.sync()``. """ def set(**attrs): """ This sets many column attributes at once. ``obj.set(a=1, b=2)`` is equivalent to ``obj.a=1; obj.b=2``, except that it will be grouped into one ``UPDATE`` """ def destroySelf(): """ Deletes this row from the database. This is called on instances, not on the class. The object still persists, because objects cannot be deleted from the Python process (they can only be forgotten about, at which time they are garbage collected). The object becomes obsolete, and further activity on it will raise errors. """ def sqlrepr(obj, connection=None): """ Returns the SQL representation of the given object, for the configured database connection. """ class Isqlmeta(Interface): table = """ The name of the table in the database. This is derived from ``style`` and the class name if no explicit name is given. """ idName = """ The name of the primary key column in the database. This is derived from ``style`` if no explicit name is given. """ idType = """ A function that coerces/normalizes IDs when setting IDs. This is ``int`` by default (all IDs are normalized to integers). """ style = """ An instance of the ``IStyle`` interface. This maps Python identifiers to database names. """ lazyUpdate = """ A boolean (default false). If true, then setting attributes on instances (or using ``inst.set(...)`` will not send ``UPDATE`` queries immediately (you must call ``inst.syncUpdates()`` or ``inst.sync()`` first). """ defaultOrder = """ When selecting objects and not giving an explicit order, this attribute indicates the default ordering. It is like this value is passed to ``.select()`` and related methods; see those method's documentation for details. """ cacheValues = """ A boolean (default true). If true, then the values in the row are cached as long as the instance is kept (and ``inst.expire()`` is not called). If false, then every attribute access causes a ``SELECT`` (which is absurdly inefficient). """ registry = """ Because SQLObject uses strings to relate classes, and these strings do not respect module names, name clashes will occur if you put different systems together. This string value serves as a namespace for classes. """ fromDatabase = """ A boolean (default false). If true, then on class creation the database will be queried for the table's columns, and any missing columns (possible all columns) will be added automatically. """ columns = """ A dictionary of ``{columnName: anSOColInstance}``. You can get information on the columns via this read-only attribute. """ columnList = """ A list of the values in ``columns``. Sometimes a stable, ordered version of the columns is necessary; this is used for that. """ columnDefinitions = """ A dictionary like ``columns``, but contains the original column definitions (which are not class-specific, and have no logic). """ joins = """ A list of all the Join objects for this class. """ indexes = """ A list of all the indexes for this class. """ # Instance attributes expired = """ A boolean. If true, then the next time this object's column attributes are accessed a query will be run. """ # Methods def addColumn(columnDef, changeSchema=False, connection=None): """ Adds the described column to the table. If ``changeSchema`` is true, then an ``ALTER TABLE`` query is called to change the database. Attributes given in the body of the SQLObject subclass are collected and become calls to this method. """ def delColumn(column, changeSchema=False, connection=None): """ Removes the given column (either the definition from ``columnDefinition`` or the SOCol object from ``columns``). If ``changeSchema`` is true, then an ``ALTER TABLE`` query is made. """ def addColumnsFromDatabase(connection=None): """ Adds all the columns from the database that are not already defined. If the ``fromDatabase`` attribute is true, then this is called on class instantiation. """ def addJoin(joinDef): """ Adds a join to the class. """ def delJoin(joinDef): """ Removes a join from the class. """ def addIndex(indexDef): """ Adds the index to the class. """ def asDict(): """ Returns the SQLObject instance as a dictionary (column names as keys, column values as values). Use like:: ASQLObjectClass(a=1, b=2).asDict() Which should return ``{'a': 1, 'b': 2}``. Note: this is a *copy* of the object's columns; changing the dictionary will not effect the object it was created from. """ class ICol(Interface): def __init__(name=None, **kw): """ Creates a column definition. This is an object that describes a column, basically just holding the keywords for later creating an ``SOCol`` (or subclass) instance. Subclasses of ``Col`` (which implement this interface) typically create the related subclass of ``SOCol``. """ name = """ The name of the column. If this is not given in the constructor, ``SQLObject`` will set this attribute from the variable name this object is assigned to. """ class ISOCol(Interface): """ This is a column description that is bound to a single class. This cannot be shared by subclasses, so a new instance is created for every new class (in cases where classes share columns). These objects are created by ``Col`` instances, you do not create them directly. """ name = """ The name of the attribute that points to this column. This is the Python name of the column. """ columnDef = """ The ``Col`` object that created this instance. """ immutable = """ Boolean, default false. If true, then this column cannot be modified. It cannot even be modified at construction, rendering the table read-only. This will probably change in the future, as it renders the option rather useless. """ cascade = """ If a foreign key, then this indicates if deletes in that foreign table should cascade into this table. This can be true (deletes cascade), false (the default, they do not cascade), or ``'null'`` (this column is set to ``NULL`` if the foreign key is deleted). """ constraints = """ A list of ... @@? """ notNone = """ Boolean, default false. It true, then ``None`` (aka ``NULL``) is not allowed in this column. Also the ``notNull`` attribute can be used. """ foreignKey = """ If not None, then this column points to another table. The attribute is the name (a string) of that table/class. """ dbName = """ The name of this column in the database. """ alternateID = """ Boolean, default false. If true, then this column is assumed to be unique, and you can fetch individual rows based on this column's value. This will add a method ``byAttributeName`` to the parent SQLObject subclass. """ unique = """ Boolean, default false. If this column is unique; effects the database ``CREATE`` statement, and is implied by ``alternateID=True``. """ validator = """ A IValidator object. All setting of this column goes through the ``fromPython`` method of the validator. All getting of this column from the database goes through ``toPython``. """ default = """ A value that holds the default value for this column. If the default value passed in is a callable, then that value is called to return a default (a typical example being ``DateTime.now``). """ sqlType = """ The SQL type of the column, overriding the default column type. """ SQLObject-3.1.0/docs/Authors.rst0000644000175000017500000000317212752476767016012 0ustar phdphd00000000000000Authors ======= SQLObject was originally written by Ian Bicking . Contributions have been made by: * Frank Barknecht * Bud P. Bruegger * David M. Cook * Luke Opperman * James Ralston * Sidnei da Silva * Brad Bollenbach * Daniel Savard, Xsoli Inc * alexander smishlajev * Yaroslav Samchuk * Runar Petursson * J Paulo Fernandes Farias * Shahms King * David Turner, The Open Planning Project * Dan Pascu * Diez B. Roggisch * Christopher Singley * David Keeney * Daniel Fetchinson * Neil Muller * Petr Jakes * Ken Lalonde * Andrew Ziem * Andrew Trusty * Ian Cordasco * Lukasz Dobrzanski * Gregor Horvath * Nathan Edwards * Lutz Steinborn * Oleg Broytman .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/News4.rst0000644000175000017500000002257312752476767015373 0ustar phdphd00000000000000++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 0.15.1 ================ Released 22 Mar 2011. * A bug was fixed in MSSQLConnection. * A minor bug was fixed in sqlbuilder.Union. SQLObject 0.15.0 ================ Released 6 Dec 2010. Features & Interface -------------------- * Major API change: all signals are sent with the instance (or the class) as the first parameter. The following signals were changed: RowCreateSignal, RowCreatedSignal, DeleteColumnSignal. * Major API change: post-processing functions for all signals are called with the instance as the first parameter. The following signals were changed: RowUpdatedSignal, RowDestroySignal, RowDestroyedSignal. SQLObject 0.14.2 ================ * A minor bug was fixed in sqlbuilder.Union. SQLObject 0.14.1 ================ Released 15 Oct 2010. * A bugfix was ported from `SQLObject 0.13.1`_. SQLObject 0.14.0 ================ Released 10 Oct 2010. Features & Interface -------------------- * The lists of columns/indices/joins are now sorted according to the order of declaration. * ``validator2`` was added to all columns; it is inserted at the beginning of the list of validators, i.e. its ``from_python()`` method is called first, ``to_python()`` is called last, after all validators in the list. * SQLiteConnection's parameter ``use_table_info`` became boolean with default value True; this means the default schema parser is now based on ``PRAGMA table_info()``. * Major API change: attribute ``dirty`` was moved to sqlmeta. SQLObject 0.13.1 ================ Released 15 Oct 2010. * A bug was fixed in a subtle case when a per-instance connection is not passed to validators. SQLObject 0.13.0 ================ Released 11 Aug 2010. Features & Interface -------------------- * SQLObject instances that don't have a per-instance connection can be pickled and unpickled. * Validators became stricter: StringCol and UnicodeCol now accept only str, unicode or an instance of a class that implements __unicode__ (but not __str__ because every object has a __str__ method); BoolCol accepts only bool or int or an instance of a class that implements __nonzero__; IntCol accepts int, long or an instance of a class that implements __int__ or __long__; FloatCol accepts float, int, long or an instance of a class that implements __float__, __int__ or __long__. * Added a connection class for rdbhost.com (commercial Postgres-over-Web service). Small Features -------------- * Added TimedeltaCol; currently it's only implemented on PostgreSQL as an INTERVAL type. * Do not pollute the base sqlmeta class to allow Style to set idName. In the case of inherited idName inherited value takes precedence; to allow Style to set idName reset inherited idName to None. * Better handling of circular dependencies in sqlobject-admin - do not include the class in the list of other classes. * Renamed db_encoding to dbEncoding in UnicodeStringValidator. * A new parameter ``sslmode`` was added to PostgresConnection. * Removed SQLValidator - its attemptConvert was never called because in FormEncode it's named attempt_convert. SQLObject 0.12.5 ================ * ``backend`` parameter was renamed to ``driver``. To preserve backward compatibility ``backend`` is still recognized and will be recognized for some time. SQLObject 0.12.4 ================ Released 5 May 2010. * Bugs were fixed in calling from_python(). * A bugfix was ported from `SQLObject 0.11.6`_. SQLObject 0.12.3 ================ Released 11 Apr 2010. * A bugfix ported from `SQLObject 0.11.5`_. SQLObject 0.12.2 ================ Released 4 Mar 2010. * Bugfixes ported from `SQLObject 0.11.4`_. SQLObject 0.12.1 ================ Released 8 Jan 2010. * Fixed three bugs in PostgresConnection. * A number of changes ported from `SQLObject 0.11.3`_. SQLObject 0.12 ============== Released 20 Oct 2009. Features & Interface -------------------- * .selectBy(), .deleteBy() and .by*() methods pass all values through .from_python(), not only unicode. * The user can choose a DB API driver for SQLite by using a ``backend`` parameter in DB URI or SQLiteConnection that can be a comma-separated list of backend names. Possible backends are: ``pysqlite2`` (alias ``sqlite2``), ``sqlite3``, ``sqlite`` (alias ``sqlite1``). Default is to test pysqlite2, sqlite3 and sqlite in that order. * The user can choose a DB API driver for PostgreSQL by using a ``backend`` parameter in DB URI or PostgresConnection that can be a comma-separated list of backend names. Possible backends are: ``psycopg2``, ``psycopg1``, ``psycopg`` (tries psycopg2 and psycopg1), ``pygresql``. Default is ``psycopg``. WARNING: API change! PostgresConnection's parameter ``usePygresql`` is now replaced with ``backend=pygresql``. * The user can choose a DB API driver for MSSQL by using a ``backend`` parameter in DB URI or MSSQLConnection that can be a comma-separated list of backend names. Possible backends are: ``adodb`` (alias ``adodbapi``) and ``pymssql``. Default is to test adodbapi and pymssql in that order. * alternateMethodName is defined for all unique fields, not only alternateID; this makes SQLObject create .by*() methods for all unique fields. * SET client_encoding for PostgreSQL to the value of ``charset`` parameter in DB URI or PostgresConnection. * TimestampCol() can be instantiated without any defaults, in this case default will be None (good default for TIMESTAMP columns in MySQL). Small Features -------------- * Imported DB API drivers are stored as connection instance variables, not in global variables; this allows to use different DB API drivers at the same time; for example, PySQLite2 and sqlite3. * Removed all deprecated attributes and functions. * Removed the last remained string exceptions. SQLObject 0.11.6 ================ Released 5 May 2010. * A bug was fixed in SQLiteConnection.columnsFromSchema(): pass None as size/precision to DecimalCol; DecimalCol doesn't allow default values (to force user to pass meaningful values); but columnsFromSchema() doesn't implement proper parsing of column details. SQLObject 0.11.5 ================ Released 11 Apr 2010. * Fixed a bug in replacing _connection in a case when no previous _connection has been set. SQLObject 0.11.4 ================ Released 4 Mar 2010. * Fixed a bug in inheritance - if creation of the row failed and if the connection is not a transaction and is in autocommit mode - remove parent row(s). * Do not set _perConnection flag if get() or _init() is passed the same connection; this is often the case with select(). SQLObject 0.11.3 ================ Released 8 Jan 2010. * Fixed a bug in col.py and dbconnection.py - if dbEncoding is None suppose it's 'ascii'. * Fixed a bug in FirebirdConnection. * The cache culling algorithm was enhanced to eliminate memory leaks by removing references to dead objects; tested on a website that runs around 4 million requests a day. SQLObject 0.11.2 ================ Released 30 Sep 2009. * Fixed a bug in logging to console - convert unicode to str. * Fixed an obscure bug in ConnectionHub triggered by an SQLObject class whose instances can be coerced to boolean False. SQLObject 0.11.1 ================ Released 20 Sep 2009. * Fixed a bug: Sybase tables with identity column fire two identity_inserts. * Fixed a bug: q.startswith(), q.contains() and q.endswith() escape (with a backslash) all special characters (backslashes, underscores and percent signs). SQLObject 0.11.0 ================ Released 12 Aug 2009. Features & Interface -------------------- * Dropped support for Python 2.3. The minimal version of Python for SQLObject is 2.4 now. * Dropped support for PostgreSQL 7.2. The minimal supported version of PostgreSQL is 7.3 now. * New magic attribute ``j`` similar to ``q`` was added that automagically does join with the other table in MultipleJoin or RelatedJoin. * SQLObject can now create and drop a database in MySQL, PostgreSQL, SQLite and Firebird/Interbase. * Added some support for schemas in PostgreSQL. * Added DecimalStringCol - similar to DecimalCol but stores data as strings to work around problems in some drivers and type affinity problem in SQLite. * Added sqlobject.include.hashcol.HashCol - a column type that automatically hashes anything going into it, and returns out an object that hashes anything being compared to itself. Basically, it's good for really simple one-way password fields, and it even supports the assignment of None to indicate no password set. By default, it uses the md5 library for hashing, but this can be changed in a HashCol definition. * RowDestroyedSignal and RowUpdatedSignal were added. Minor features -------------- * Use reversed() in manager/command.py instead of .__reversed__(). * Minor change in logging to console - logger no longer stores the output file, it gets the file from module sys every time by name; this means logging will use new sys.stdout (or stderr) in case the user changed them. * Changed the order of testing of SQLite modules - look for external PySQLite2 before sqlite3. `Older news`__ .. __: News3.html .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/News5.rst0000644000175000017500000003347312752476767015375 0ustar phdphd00000000000000++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 2.2.1 =============== Released 10 May 2016. * Fix a bug in sqlbuilder.CONCAT (inherit from SQLExpression). SQLObject 2.2.0 =============== Released 8 May 2016. Features & Interface -------------------- * Add function col.use_microseconds(True/False). Default is to use microseconds (True). * For MSSQL use datetime2(6) and time(6) columns. * Columns for ForeignKey are created using idType of the referenced table. Minor features -------------- * Add sqlbuilder.CONCAT to generate concatenation command (either using function CONCAT() or '||' operator). * Minor refactoring to pave the way to Python 3 was merged from `SQLObject 1.6.7`_. * Document MSSQL server versions -- merged from `SQLObject 1.7.6`_. Bugfixes -------- * Fix a bug: mxDateTime doesn't support microseconds; %s in mxDateTime format means ticks. Tests ----- * Speedup SQLite connections in tests -- merged from `SQLObject 1.7.6`_. * Added new test helper setupCyclicClasses to setup classes with mutual references. SQLObject 2.1.2 =============== Released 15 Mar 2015. * Using fdb adapter for Firebird was ported from `SQLObject 1.6.6`_. SQLObject 2.1.1 =============== Released 10 Mar 2015. * Minor fix in PostgresConnection was ported from `SQLObject 1.6.5`_. SQLObject 2.1.0 =============== Released 6 Jan 2015. Minor features -------------- * In queries generated with SQLObject's tables columns are sorted in the order they are declared in the table. * In queries generated with sqlbuilder's Insert/Update, if values are passed using dictionaries, columns are sorted alphabetically. * Tables in SELECT...FROM clause are sorted alphabetically. * MySQLConnection, PostgresConnection and SQLiteConnection have got a new method listDatabases() that lists databases in the connection and returns a list of names. * MySQLConnection, PostgresConnection and SQLiteConnection have got a new method listTables() that returns a list of table names in the database. SQLObject 2.0.0 =============== Released 20 Dec 2014. Features & Interface -------------------- * DateTimeCol and TimeCol can read and write values with microseconds. WARNING: microseconds are supported by MariaDB since version 5.3.0 and by MySQL since version 5.6.4, and even these versions require special handling: columns to store microseconds have to be declared with precision 6: TIME(6), DATETIME(6), TIMESTAMP(6). SQLObject does the right thing when creating a new database but existing databases have to be changed: run something like ``ALTER TABLE name MODIFY COLUMN col TIME(6)`` for every column that you want to store microseconds. For MSSQL use datetime2(6) and time(6) columns. They are available since MS SQL Server 2008. WARNING: backward compatibility problem! Date/Time columns created with microseconds cannot be read back from SQLite databases (and perhaps other backends) with versions of SQLObject older than 1.7. Minor features -------------- * PostgresConnection, when used with fromDatabase=True, sets alternateID for unique columns. Development ----------- * Development was switched from Subversion to git. Documentation ------------- * Old news were restored back to version 0.2.1. * News.txt was split into 5 small files. SQLObject 1.7.6 =============== * Minor refactoring to pave the way to Python 3 was merged from `SQLObject 1.6.7`_. * Document MSSQL server versions -- merged from `SQLObject 1.6.7`_. * Speedup SQLite connections in tests -- merged from `SQLObject 1.6.7`_. SQLObject 1.7.5 =============== Released 15 Mar 2015. * Using fdb adapter for Firebird was ported from `SQLObject 1.6.6`_. SQLObject 1.7.4 =============== Released 10 Mar 2015. * Minor fix in PostgresConnection was ported from `SQLObject 1.6.5`_. SQLObject 1.7.3 =============== Released 18 Dec 2014. * Documentation updates and setup.py change were ported from `SQLObject 1.5.6`_. SQLObject 1.7.2 =============== Released 14 Dec 2014. * Fix a bug: zero-pad microseconds on the right, not on the left; 0.0835 seconds means 83500 microseconds. SQLObject 1.7.1 =============== Released 11 Dec 2014. * Documentation updates and setuptools change were ported from `SQLObject 1.5.5`_. SQLObject 1.7.0 =============== Released 8 Dec 2014. Features & Interface -------------------- * Python 2.5 is no longer supported. The minimal supported version is Python 2.6. * DateTimeCol and TimeCol can read values with microseconds (created by SQLObject 2.0) but do not write microseconds back. Minor features -------------- * Upgrade ez_setup to 2.2. Bugfixes -------- * Thre bugfixes were ported from `SQLObject 1.5.2`_, `SQLObject 1.5.3`_ and `SQLObject 1.5.4`_. SQLObject 1.6.7 =============== * Minor refactoring to pave the way to Python 3: replace calls like ``unicode(data, encoding)`` with ``data.decode(encoding)``. * Document MSSQL server versions. * Minor fix in HashCol. * Speedup SQLite connections in tests. SQLObject 1.6.6 =============== Released 15 Mar 2015. * Use fdb adapter for Firebird. SQLObject 1.6.5 =============== Released 10 Mar 2015. * Minor fix in PostgresConnection: close the cursor and connection in _createOrDropDatabase even after an error. SQLObject 1.6.4 =============== Released 18 Dec 2014. * Documentation updates and setup.py change were ported from `SQLObject 1.5.6`_. SQLObject 1.6.3 =============== Released 11 Dec 2014. * Documentation updates and setuptools change were ported from `SQLObject 1.5.5`_. SQLObject 1.6.2 =============== Released 8 Dec 2014. * A bugfix was ported from `SQLObject 1.5.4`_. SQLObject 1.6.1 =============== Released 26 Oct 2014. * A bugfix was ported from `SQLObject 1.5.3`_. SQLObject 1.6.0 =============== Released 15 May 2014. Features & Interface -------------------- * Python 2.4 is no longer supported. The minimal supported version is Python 2.5. * Support for Python 2.5 is declared obsolete and will be removed in the next release. Minor features -------------- * Upgrade ez_setup to 1.4.2. Bugfixes -------- * A bugfix was ported from `SQLObject 1.5.2`_. Development ----------- * Development switched from Subvesion to git. SQLObject 1.5.6 =============== Released 18 Dec 2014. * Extend setup.py: include docs and tests into the egg. SQLObject 1.5.5 =============== Released 11 Dec 2014. * Documentation update: change URLs for development with git, add Travis CI build status image. * Extend sdist: include everything into source distribution. SQLObject 1.5.4 =============== Released 8 Dec 2014. * Fix a minor bug in MSSQLConnection: do not override callable server_version with a non-callable. SQLObject 1.5.3 =============== Released 26 Oct 2014. * Allow unicode in .orderBy(u'-column'). Development ----------- * Development switched from Subvesion to git. SQLObject 1.5.2 =============== Released 13 Apr 2014. * Adapt duplicate error message strings for SQLite 3.8. SQLObject 1.5.1 =============== Released 15 Dec 2013. * SQLiteConnection.close() now closes and reopens a connection to in-memory database. SQLObject 1.5.0 =============== Released 5 Oct 2013. Features & Interface -------------------- * Helpers for class Outer were changed to lookup columns in table's declarations. * Support for Python 2.4 is declared obsolete and will be removed in the next release. Minor features -------------- * When a PostgresConnection raises an exception the instance has code/error attributes copied from psycopg2's pgcode/pgerror attributes. * Encode unicode enum values to str. * Removed setDeprecationLevel from the list of public functions. * A number of fixes for tests. Bugfixes -------- * A bug was fixed in DBConnection.close(); close() doesn't raise an UnboundLocalError if connection pool is empty. * Fixed parameters for pymssql. Documentation ------------- * GNU LGPL text was added as docs/LICENSE file. * Old FSF address was changed to the new one. SQLObject 1.4.1 =============== Released 26 May 2013. * A few bugfixes were ported from `SQLObject 1.3.3`_. SQLObject 1.4.0 =============== Released 18 May 2013. Features & Interface -------------------- * Support for PostgreSQL 8.1 is dropped. The minimal supported version of PostgreSQL is 8.2 now. * Optimization in PostgresConnection: use INSERT...RETURNING id to get the autoincremented id in one query instead of two (INSERT + SELECT id). * Changed the way to get if the table has identity in MS SQL. * NCHAR/NVARCHAR and N''-quoted strings for MS SQL. SQLObject 1.3.3 =============== Released 26 May 2013. * Fixed bugs in pickling and unpickling (remove/restore a weak proxy to self, fixed cache handling). * Added an example of using SQLObject with web.py by Rhubarb Sin to the links page. SQLObject 1.3.2 =============== Released 20 Oct 2012. * A number of bugfixes were ported from `SQLObject 1.2.4`_. SQLObject 1.3.1 =============== Released 25 May 2012. * Two bugfixes were ported from `SQLObject 1.2.3`_. SQLObject 1.3.0 =============== Released 31 Mar 2012. Features & Interface -------------------- * PostgresConnection performs translation of exceptions to standard SQLObject's hierarchy of exceptions. * Major update of FirebirdConnection: introspection was completely rewritten and extended; ``charset`` was renamed to ``dbEncoding``; a longstanding bug was fixed - pass port to connect(). SQLObject 1.2.4 =============== Released 20 Oct 2012. * Fixed a bug in sqlbuilder.Select.filter - removed comparison with SQLTrueClause. * Neil Muller fixed a number of tests. SQLObject 1.2.3 =============== Released 25 May 2012. * Fixed a minor bug in PostgreSQL introspection: VIEWs don't have PRIMARY KEYs - use sqlmeta.idName as the key. * Fixed a bug in cache handling while unpickling. SQLObject 1.2.2 =============== Released 1 Mar 2012. * A bugfix was ported from `SQLObject 1.1.5`_. SQLObject 1.2.1 =============== Released 4 Dec 2011. * A bugfix was ported from `SQLObject 1.1.4`_. SQLObject 1.2.0 =============== Released 20 Nov 2011. Features & Interface -------------------- * Strings are treated specially in Select to allow Select(['id, 'name'], where='value = 42'). Update allows a string in WHERE. * ForeignKey('Table', refColumn='refcol_id') to allow ForeignKey to point to a non-id column; the referred column must be a unique integer column. * delColumn now accepts a ForeignKey's name without 'ID'. * Support for PostgreSQL 7.* is dropped. The minimal supported version of PostgreSQL is 8.1 now. * Quoting rules changed for PostgreSQL: SQLObject uses E'' escape string if the string contains characters escaped with backslash. * A bug caused by psycopg2 recently added a new boolean not callable autocommit attribute was fixed. * sqlobject.__doc__ and main.__doc__ no longer contain version number. Use sqlobject.version or version_info. SQLObject 1.1.5 =============== Released 1 Mar 2012. * A bug was fixed in SQLiteConnection - clear _threadPool on close(). SQLObject 1.1.4 =============== Released 4 Dec 2011. * A bug was fixed in handling ``modulo`` operator - SQLite implements only ``%``, MySQL - only ``MOD()``, PostgreSQL implements both. SQLObject 1.1.3 =============== Released 30 Aug 2011. * A bugfix was ported from `SQLObject 1.0.3`_. SQLObject 1.1.2 =============== Released 8 Aug 2011. * A bugfix was ported from `SQLObject 1.0.2`_. SQLObject 1.1.1 =============== Released 1 Jul 2011. * Parsing sqlobject.__doc__ for version number is declared obsolete. Use sqlobject.version or version_info. * Documented sqlmeta.dbEncoding and connection.dbEncoding. SQLObject 1.1 ============= Released 20 Jun 2011. Features & Interface -------------------- * SelectResults (returned from .select()) is allowed in IN(column, list). * A different workaround is used in SQLiteConnection to prevent PySQLite from converting strings to unicode - in the case of a registered text conversion function PySQLite silently converts empty strings to Nones; now SQLObject uses text_factory instead and properly returns empty strings. * It is now possible to declare one encoding for all UnicodeCol's per table (as sqlmeta.dbEncoding) or per connection (as connection.dbEncoding). Default (if dbEncoding is found neither in column nor in table nor in connection) is 'utf-8'. Source code and internals ------------------------- * Decorators @classmethod and @staticmethod are used everywhere. * All 'mydict.has_key(name)' checks were replaced with 'name in mydict'. SQLObject 1.0.3 =============== Released 30 Aug 2011. * Fixed a bug with Postgres - add quotes in "SET client_encoding" query. SQLObject 1.0.2 =============== Released 8 Aug 2011. * A bug was fixed in SelectResults slicing that prevented to slice a slice (my_results[:20][1:5]). SQLObject 1.0.1 =============== Released 30 May 2011. * A syntax incompatibility was fixed in SQLiteConnection that prevented SQLObject to be used with Python 2.4. SQLObject 1.0.0 =============== Released 28 Mar 2011. Features & Interface -------------------- * Major API change: DB URI parser was changed to use urllib.split*() and unquote(). This means any username/password/path are allowed in DB URIs if they are properly %-encoded, and DB URIs are automatically unquoted. * A new module ``__version__.py`` was added. New variables ``version`` (string) and ``version_info`` (5-tuple: major, minor, micro, release level, serial) are imported into ``sqlobject`` namespace. * In SQLite, id columns are made AUTOINCREMENT. * Parameter ``backend`` in DB URI is no longer supported, use parameter ``driver``. `Older news`__ .. __: News4.html .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/SQLBuilder.rst0000644000175000017500000002176612752476767016344 0ustar phdphd00000000000000`````````` SQLBuilder `````````` .. contents:: A number of variables from SQLBuilder are included with ``from sqlobject import *`` -- see the `relevant SQLObject documentation`_ for more. Its functionality is also available through the special ``q`` attribute of `SQLObject` classes. .. _`relevant SQLObject documentation`: SQLObject.html#exported-symbols SQLExpression ============= SQLExpression uses clever overriding of operators to make Python expressions build SQL expressions -- so long as you start with a Magic Object that knows how to fake it. With SQLObject, you get a Magic Object by accessing the ``q`` attribute of a table class -- this gives you an object that represents the field. All of this is probably easier to grasp in an example:: >>> from sqlobject.sqlbuilder import * >>> person = table.person # person is now equivalent to the Person.q object from the SQLObject # documentation >>> person person >>> person.first_name person.first_name >>> person.first_name == 'John' person.first_name = 'John' >>> name = 'John' >>> person.first_name != name person.first_name != 'John' >>> AND(person.first_name == 'John', person.last_name == 'Doe') (person.first_name = 'John' AND person.last_name = 'Doe') Most of the operators work properly: <, >, <=, >=, !=, ==, +, -, /, \*, \*\*, %. However, ``and``, ``or``, and ``not`` **do not work**. You can use &, \|, and ~ instead -- but be aware that these have the same precedence as multiplication. So:: # This isn't what you want: >> person.first_name == 'John' & person.last_name == 'Doe' (person.first_name = ('John' AND person.last_name)) = 'Doe') # This is: >> (person.first_name == 'John') & (person.last_name == 'Doe') ((person.first_name = 'John') AND (person.last_name == 'Doe')) SQLBuilder also contains the functions ``AND``, ``OR``, and ``NOT`` which also work -- I find these easier to work with. ``AND`` and ``OR`` can take any number of arguments. You can also use ``.startswith()`` and ``.endswith()`` on an SQL expression -- these will translate to appropriate ``LIKE`` statements and all ``%`` quoting is handled for you, so you can ignore that implementation detail. There is also a ``LIKE`` function, where you can pass your string, with ``%`` for the wildcard, as usual. If you want to access an SQL function, use the ``func`` variable, like:: >> person.created < func.NOW() To pass a constant, use the ``const`` variable which is actually an alias for func. SQL statements ============== SQLBuilder implements objects that execute SQL statements. SQLObject uses them internally in its `higher-level API`_, but users can use this mid-level API to execute SQL queries that are not supported by the high-level API. To use these objects first construct an instance of a statement object, then ask the connection to convert the instance to an SQL query and finally ask the connection to execute the query and return the results. For example, for ``Select`` class:: >>> from sqlobject.sqlbuilder import * >> select = Select(['name', 'AVG(salary)'], staticTables=['employees'], >> groupBy='name') # create an instance >> query = connection.sqlrepr(select) # Convert to SQL string: >> # SELECT name, AVG(salary) FROM employees GROUP BY name >> rows = connection.queryAll(query) # Execute the query >> # and get back the results as a list of rows >> # where every row is a sequence of length 2 (name and average salary) .. _`higher-level API`: SQLObject.html Select ~~~~~~ A class to build ``SELECT`` queries. Accepts a number of parameters, all parameters except `items` are optional. Use ``connection.queryAll(query)`` to execute the query and get back the results as a list of rows. `items`: A string, an SQLExpression or a sequence of strings or SQLExpression's, represents the list of columns. If there are q-values SQLExpression's ``Select`` derives a list of tables for SELECT query. `where`: A string or an SQLExpression, represents the ``WHERE`` clause. `groupBy`: A string or an SQLExpression, represents the ``GROUP BY`` clause. `having`: A string or an SQLExpression, represents the ``HAVING`` part of the ``GROUP BY`` clause. `orderBy`: A string or an SQLExpression, represents the ``ORDER BY`` clause. `join`: A (list of) JOINs (``LEFT JOIN``, etc.) `distinct`: A bool flag to turn on ``DISTINCT`` query. `start`, `end`: Integers. The way to calculate ``OFFSET`` and ``LIMIT``. `limit`: An integer. `limit`, if passed, overrides `end`. `reversed`: A bool flag to do ``ORDER BY`` in the reverse direction. `forUpdate`: A bool flag to turn on ``SELECT FOR UPDATE`` query. `staticTables`: A sequence of strings or SQLExpression's that name tables for ``FROM``. This parameter must be used if `items` is a list of strings from which Select cannot derive the list of tables. Insert ~~~~~~ A class to build ``INSERT`` queries. Accepts a number of parameters. Use ``connection.query(query)`` to execute the query. `table`: A string that names the table to ``INSERT`` into. Required. `valueList`: A list of (key, value) sequences or {key: value} dictionaries; keys are column names. Either `valueList` or `values` must be passed, but not both. Example:: >> insert = Insert('person', valueList=[('name', 'Test'), ('age', 42)]) # or >> insert = Insert('person', valueList=[{'name': 'Test'}, {'age': 42}]) >> query = connection.sqlrepr(insert) # Both generate the same query: # INSERT INTO person (name, age) VALUES ('Test', 42) >> connection.query(query) `values`: A dictionary {key: value}; keys are column names. Either `valueList` or `values` must be passed, but not both. Example:: >> insert = Insert('person', values={'name': 'Test', 'age': 42}) >> query = connection.sqlrepr(insert) # The query is the same # INSERT INTO person (name, age) VALUES ('Test', 42) >> connection.query(query) Instances of the class work fast and thus are suitable for mass-insertion. If one needs to populate a database with SQLObject running a lot of ``INSERT`` queries this class is the way to go. Update ~~~~~~ A class to build ``UPDATE`` queries. Accepts a number of parameters. Use ``connection.query(query)`` to execute the query. `table`: A string that names the table to ``UPDATE``. Required. `values`: A dictionary {key: value}; keys are column names. Required. `where`: An optional string or SQLExpression, represents the ``WHERE`` clause. Example:: >> update = Update('person', >> values={'name': 'Test', 'age': 42}, where='id=1') >> query = connection.sqlrepr(update) # UPDATE person SET name='Test', age=42 WHERE id=1 >> connection.query(query) Delete ~~~~~~ A class to build ``DELETE FROM`` queries. Accepts a number of parameters. Use ``connection.query(query)`` to execute the query. `table`: A string that names the table to ``UPDATE``. Required. `where`: An optional string or an SQLExpression, represents the ``WHERE`` clause. Required. If you need to delete all rows pass ``where=None``; this is a safety measure. Example:: >> update = Delete('person', where='id=1') >> query = connection.sqlrepr(update) # DELETE FROM person WHERE id=1 >> connection.query(query) Union ~~~~~ A class to build ``UNION`` queries. Accepts a number of parameters - ``Select`` queries. Use ``connection.queryAll(query)`` to execute the query and get back the results. Example:: >> select1 = Select(['min', func.MIN(const.salary)], staticTables=['employees']) >> select2 = Select(['max', func.MAX(const.salary)], staticTables=['employees']) >> union = Union(select1, select2) >> query = connection.sqlrepr(union) # SELECT 'min', MIN(salary) FROM employees # UNION # SELECT 'max', MAX(salary) FROM employees >> rows = connection.queryAll(query) Nested SQL statements (subqueries) ================================== There are a few special operators that receive as parameter SQL statements. These are ``IN``, ``NOTIN``, ``EXISTS``, ``NOTEXISTS``, ``SOME``, ``ANY`` and ``ALL``. Consider the following example: You are interested in removing records from a table using deleteMany. However, the criterion for doing so depends on another table. You would expect the following to work:: >> PersonWorkplace.deleteMany(where= ((PersonWorkplace.q.WorkplaceID==Workplace.q.id) & (Workplace.q.id==SOME_ID))) But this doesn't work! However, you can't do a join in a deleteMany call. To work around this issue, use ``IN``:: >> PersonWorkplace.deleteMany(where= IN(PersonWorkplace.q.WorkplaceID, Select(Workplace.q.id, Workplace.q.id==SOME_ID))) .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/presentation-2004-11/0000755000175000017500000000000012754657361017136 5ustar phdphd00000000000000SQLObject-3.1.0/docs/presentation-2004-11/sqlobject-and-database-programming.html0000644000175000017500000004310210707101542026611 0ustar phdphd00000000000000 SQLObject and Database Programming in Python

SQLObject and Database Programming in Python

Ian Bicking

Imaginary Landscape

The Ongoing Example

Address book:

  • person:
    • first_name
    • last_name
    • email (many emails for one person)
  • email:
    • type
    • address

The DB API

Database programming in Python is based on the DB-API. Some supported databases:

  • MySQL
  • PostgreSQL (multiple drivers)
  • SQLite
  • Firebird (Interbase)
  • MAXDB (SAP DB)
  • Oracle, Sybase, MS SQL Server

DB API Example

Example: 

import MySQLdb
conn = MySQLdb.connect(
    db='test', username='ianb')
cur = conn.cursor()
cur.execute(
    "SELECT id, first_name, last_name FROM person")
result = cur.fetchall()
for id, first_name, last_name in result:
    print "%2i %s, %s" % (id, last_name, first_name)

DB API

  • Import the database module (MySQLdb, psycopg, sqlite, etc)
  • Use module.connect(...) to create a connection.
  • Use connection.cursor() to get a cursor. Cursors do all the work.
  • Use cursor.execute(sql_query) to run something.
  • Use cursor.fetchall() to get results.

DB API problems

  1. Connections and cursors are tedious.
  2. The databases don't all work the same; multiple SQL dialects.
  3. Lots of time spent writing SQL.
  4. Database updates can effect all the SQL you've written.
  5. Unless you make abstractions...

Abstractions

  • Every significant database application has a database abstraction layer.
  • You write one whether you mean to or not.

Object-Relational Mappers

The table:
person
id first_name last_name
1 John Doe
2 Tom Jones
...

ORMs: Classes

The class:
person
id first_name last_name
1 John Doe
2 Tom Jones
... 
class Person(SQLObject):
    # id is implicit
    first_name = StringCol()
    last_name = StringCol()

ORMs: Instances

An instance:
person
id first_name last_name
1 John Doe
2 Tom Jones
... 
>>> john = Person.get(1)
>>> john.first_name
'John'

ORM: summary

  • Every table is a class
  • Every row is an instance
  • Columns become attributes

Usage

__connection__ = 'postgres://pgsql@localhost/test'
class Person(SQLObject):
    first_name = StringCol()
    last_name = StringCol()
    emails = MultipleJoin('Email')

Usage (classes)

class Email(SQLObject):
    person = ForeignKey('Person')
    type = EnumCol(['home', 'work'])
    address = StringCol()

Usage (creating tables)

def createTables():
    for table in (Person, Email):
        table.createTable(ifNotExists=True)

Usage (instances)

Using your classes: 
>>> john = Person(first_name='John', last_name='Doe')
>>> email = Email(person=john, type='home', 
...     address='john@work.com')
>>> john.emails
[]

Usage (instances)

>>> tom = Person(first_name='Tom', last_name='Jones')
>>> tom is Person.get(tom.id)
True
>>> list(Person.selectBy(first_name='John'))
[]

Defining Classes

  • The class name matches the table name
  • The attributes match the column names
  • (kind of...)

Defining Classes...

You can add extra methods: 

class Person(SQLObject):
    ...
    def _get_name(self):
        return self.first_name + ' ' + self.last_name

>>> tom.name
'Tom Jones'

Automatic properties

  • _get_attr() methods are called whenever the obj.attr attribute is called
  • _set_attr() methods are called whenever the obj.attr = value statement is run
  • _set_attr() is optional

Defining classes...

You can override columns: 

class Person(SQLObject):
    ...
    last_name_searchable = StringCol()
    def _set_last_name(self, value):
        self._SO_set_last_name(self, value)
        self.last_name_lower = re.sub(r'[^a-zA-Z]', '', value).lower()

Defining classes...

You can fiddle with the naming: 

class Person(SQLObject):
    _table = "people"
    first_name = StringCol(dbName="fname")
    ...

Connecting classes

Foreign Keys: 

class Email(SQLObject):
    person = ForeignKey('Person')
    ...
Note we use a string for 'Person'.

Backreferences

The other side of one-to-many: 

class Person(SQLObject):
    ...
    emails = MultipleJoin('Email')

Many-to-many

Many to many relationships imply a "hidden" table: 

class Address(SQLObject):
    people = RelatedJoin('Person')
    ...
class Person(SQLObject):
    addresses = RelatedJoin('Address')

Many-to-many...

The intermediate table created: 

CREATE TABLE address_person (
  address_id INT NOT NULL,
  person_id INT NOT NULL
);

Lazy classes

SQLObject can use reflection to figure out what columns your table has: 

class Person(SQLObject):
    _fromDatabase = True
You can start with _fromDatabase = True and add in explicit columns, overriding defaults.

Instances

  • Use Person.get(id) to retrieve a row
  • Use Person(first_name=...) to insert a row (the new object is returned)
  • Use aPerson.destroySelf() to delete a row

Updating

  • aPerson.first_name = "new_name"
    UPDATE is executed immediately
  • Update multiple columns at once:
    aPerson.set(first_name="new_fname", last_name="new_lname")

Selecting

You can use Python expressions (kind of): 

query = Person.q.first_name == "Joe"
Person.select(query)

Selecting...

  • Class.q.column_name creates a magical object that creates queries.
  • sqlrepr() turns these query objects into SQL (mostly hidden)
  • sqlrepr(Person.q.first_name == "Joe", 'mysql') creates the SQL person.first_name = 'Joe'

Selecting...

Complicated joins are possible: 

Person.select((Person.q.id == Email.q.personID)
              & (Email.q.address.startswith('joe')))
Becomes: 
SELECT person.id, person.first_name, person.last_name
FROM person, email
WHERE person.id = email.person_id
      AND email.address LIKE 'joe%'

SelectResult

Select results are more than just lists:
  • You can slice them, and LIMIT and OFFSET statements are added to your query
  • You can iterate through them, and avoid loading all objects into memory
  • You can do things like select_result.count() to run aggregate functions
  • To get a real list, you must do list(select_result)

Caching

  • SQLObject caches everything
  • Maybe too much (bad if you have multiple updaters)
  • Needs to because there's no joins
  • Has potential to be faster than ad hoc queries
  • Thread safety or thread confusion?

Performance

  • Not good if you are dealing with lots and lots of rows
  • Inserts and selects substantially slower
  • But for many applications you'll pay that price sooner or later anyway

The problem with ORMs

ORMs live in the world between Object Oriented programmers (and programs) and Relational programmers (and programs). Neither will be happy.

ORM Mismatch

  • Python classes aren't tables
  • Python instances aren't rows

ORM Mismatch: Classes

  • Databases don't have inheritance
  • Even when they do, no one uses it
  • Some tables are too boring (e.g., intermediate tables for many-to-many relationships), or don't warrant the overhead

ORM Mismatch: Instances

  • Instances get garbage collected, rows are forever
  • Rows exist even when instances don't
  • Instances may still exist when the row is gone
  • In the relational calculus, rows don't have real identity

ORM Mismatch: Relations

  • Things like joins don't make sense for objects, but are central to relations
  • Views and stored procedures also don't make sense
  • Aggregate functions and set operations aren't natural in Python (the for loop is natural)

Solving the question by avoidance

  • SQLObject doesn't let you forget SQL
  • You still have to think relationally
  • But many relational concepts don't work either
  • Advantage: it's easy

Solving the Mismatch

SQLObject's answer: don't try too hard.
  • There exist database restrictions; not every database schema maps well. (But most are fine)
  • Sometimes you have to do things more slowly or more imperatively, compared to a purely relational technique
  • There exist object restrictions; not every object-oriented concept maps well; e.g., no inheritance
  • Inheritance isn't planned; this isn't transparent persistence

Some other alternatives

Several Python ORMs exist; contrasts:
  • SQLObject doesn't try to be too OO, so it works well with normal database schemas
  • SQLObject doesn't have a compile step
  • SQLObject isn't just a SQL wrapper
  • SQLObject is reasonably complete

Other alternatives...

See the Python Wiki at: python.org/moin
The page is HigherLevelDatabaseProgramming.

SQLObject-3.1.0/docs/DeveloperGuide.rst0000644000175000017500000002606512753214361017253 0ustar phdphd00000000000000+++++++++++++++++++++++++ SQLObject Developer Guide +++++++++++++++++++++++++ .. contents:: :backlinks: none .. _start: These are some notes on developing SQLObject. Development Installation ======================== First install `FormEncode `_:: $ git clone git://github.com/formencode/formencode.git $ cd formencode $ sudo python setup.py develop Then do the same for SQLObject:: $ git clone git clone git://github.com/sqlobject/sqlobject $ cd sqlobject $ sudo python setup.py develop Or rather fork it and clone your fork. To develop a feature or a bugfix create a separate branch, push it to your fork and create a pull request to the original repo. That way CI will be triggered to test your code. Voila! The packages are globally installed, but the files from the checkout were not copied into ``site-packages``. See `setuptools `_ for more. Architecture ============ There are three main kinds of objects in SQLObject: tables, columns and connections. Tables-related objects are in `sqlobject/main.py`_ module. There are two main classes: ``SQLObject`` and ``sqlmeta``; the latter is not a metaclass but a parent class for ``sqlmeta`` attribute in every class - the authors tried to move there all attributes and methods not directly related to columns to avoid cluttering table namespace. .. _`sqlobject/main.py`: sqlobject/main.py.html Connections are instances of ``DBConnection`` class (from `sqlobject/dbconnection.py`_) and its concrete descendants. ``DBConnection`` contains generic code for generating SQL, working with transactions and so on. Concrete connection classes (like ``PostgresConnection`` and ``SQLiteConnection``) provide backend-specific functionality. .. _`sqlobject/dbconnection.py`: sqlobject/dbconnection.py.html Columns, validators and converters ---------------------------------- Columns are instances of classes from `sqlobject/col.py`_. There are two classes for every column: one is for user to include into an instance of SQLObject, an instance of the other is automatically created by SQLObject's metaclass. The two classes are usually named ``Col`` and ``SOCol``; for example, ``BoolCol`` and ``SOBoolCol``. User-visible classes, descendants of ``Col``, seldom contain any code; the main code for a column is in ``SOCol`` descendants and in validators. .. _`sqlobject/col.py`: sqlobject/col.py.html Every column has a list of validators. Validators validate input data and convert input data to python data and back. Every validator must have methods ``from_python`` and ``to_python``. The former converts data from python to internal representation that will be converted by converters to SQL strings. The latter converts data from SQL data to python. Also please bear in mind that validators can receive ``None`` (for SQL ``NULL``) and ``SQLExpression`` (an object that represents SQLObject expressions); both objects must be passed unchanged by validators. Converters from `sqlobject/converters.py`_ aren't visible to users. They are used behind the scene to convert objects returned by validators to backend-specific SQL strings. The most elaborated converter is ``StringLikeConverter``. Yes, it converts strings to strings. It converts python strings to SQL strings using backend-specific quoting rules. .. _`sqlobject/converters.py`: sqlobject/converters.py.html Let look into ``BoolCol`` as an example. The very ``BoolCol`` doesn't have any code. ``SOBoolCol`` has a method to create ``BoolValidator`` and methods to create backend-specific column type. ``BoolValidator`` has identical methods ``from_python`` and ``to_python``; the method passes ``None``, ``SQLExpression`` and bool values unchanged; int and objects that have method ``__nonzero__`` are converted to bool; other objects trigger validation error. Bool values that are returned by call to ``from_python`` will be converted to SQL strings by ``BoolConverter``; bool values from ``to_python`` (is is supposed they are originated from the backend via DB API driver) are passed to the application. Objects that are returned from ``from_python`` must be registered with converters. Another approach for ``from_python`` is to return an object that has ``__sqlrepr__`` method. Such objects convert to SQL strings themselves, converters are not used. Style Guide =========== Generally you should follow the recommendations in `PEP 8`_, the Python Style Guide. Some things to take particular note of: .. _PEP 8: http://www.python.org/dev/peps/pep-0008/ * With a few exceptions sources must be `flake8`_-clean (and hence pep8-clean). Please consider using pre-commit hook installed by running ``flake8 --install-hook``. .. _flake8: https://gitlab.com/pycqa/flake8 * **No tabs**. Not anywhere. Always indent with 4 spaces. * We don't stress too much on line length. But try to break lines up by grouping with parenthesis instead of with backslashes (if you can). Do asserts like:: assert some_condition(a, b), ( "Some condition failed, %r isn't right!" % a) * But if you are having problems with line length, maybe you should just break the expression up into multiple statements. * Blank lines between methods, unless they are very small and closely bound to each other. * *Never* use the form ``condition and trueValue or falseValue``. Break it out and use a variable. * Careful of namespace pollution. SQLObject does allow for ``from sqlobject import *`` so names should be fairly distinct, or they shouldn't be exported in ``sqlobject.__init__``. * We're very picky about whitespace. There's one and only one right way to do it. Good examples:: short = 3 longerVar = 4 if x == 4: do stuff func(arg1='a', arg2='b') func((a + b)*10) **Bad** examples:: short =3 longerVar=4 if x==4: do stuff func(arg1 = 'a', arg2 = 'b') func(a,b) func( a, b ) [ 1, 2, 3 ] To us, the poor use of whitespace seems lazy. We'll think less of your code (justified or not) for this very trivial reason. We will fix all your code for you if you don't do it yourself, because we can't bear to look at sloppy whitespace. * Use ``@@`` to mark something that is suboptimal, or where you have a concern that it's not right. Try to also date it and put your username there. * Docstrings are good. They should look like:: class AClass(object): """ doc string... """ Don't use single quotes ('''). Don't bother trying make the string less vertically compact. * Comments go right before the thing they are commenting on. * Methods never, ever, ever start with capital letters. Generally only classes are capitalized. But definitely never methods. * mixedCase is preferred. * Use ``cls`` to refer to a class. Use ``meta`` to refer to a metaclass (which also happens to be a class, but calling a metaclass ``cls`` will be confusing). * Use ``isinstance`` instead of comparing types. E.g.:: if isinstance(var, str): ... # Bad: if type(var) is StringType: ... * Never, ever use two leading underscores. This is annoyingly private. If name clashes are a concern, use name mangling instead (e.g., ``_SO_blahblah``). This is essentially the same thing as double-underscore, only it's transparent where double underscore obscures. * Module names should be unique in the package. Subpackages shouldn't share module names with sibling or parent packages. Sadly this isn't possible for ``__init__``, but it's otherwise easy enough. * Module names should be all lower case, and probably have no underscores (smushedwords). Testing ======= Tests are important. Tests keep everything from falling apart. All new additions should have tests. Testing uses py.test, an alternative to ``unittest``. It is available at http://pytest.org/ and https://pypi.python.org/pypi/pytest. Read its `getting started`_ document for more. .. _getting started: http://docs.pytest.org/en/latest/getting-started.html To actually run the test, you have to give it a database to connect to. You do so with the option ``-D``. You can either give a complete URI or one of several shortcuts like ``mysql`` (these shortcuts are defined in the top of ``tests/dbtest.py``). All the tests are modules in ``sqlobject/tests``. Each module tests one kind of feature, more or less. If you are testing a module, call the test module ``tests/test_modulename.py`` -- only modules that start with ``test_`` will be picked up by py.test. The "framework" for testing is in ``tests/dbtest``. There's a couple of important functions: ``setupClass(soClass)`` creates the tables for the class. It tries to avoid recreating tables if not necessary. ``supports(featureName)`` checks if the database backend supports the named feature. What backends support what is defined at the top of ``dbtest``. If you ``import *`` you'll also get py.test's version of raises_, an ``inserts`` function that can create instances for you, and a couple miscellaneous functions. .. _raises: http://docs.pytest.org/en/latest/assert.html#assertions-about-expected-exceptions If you submit a patch or implement a feature without a test, we'll be forced to write the test. That's no fun for us, to just be writing tests. So please, write tests; everything at least needs to be exercised, even if the tests are absolutely complete. We now use Travis CI and Circle CI to run tests. See the statuses: .. image:: https://travis-ci.org/sqlobject/sqlobject.svg?branch=master :target: https://travis-ci.org/sqlobject/sqlobject .. image:: https://circleci.com/gh/sqlobject/sqlobject.svg?style=shield :target: https://circleci.com/gh/sqlobject/sqlobject To avoid triggering unnecessary test run at CI services add text `[skip ci] `_ or `[ci skip] `_ anywhere in your commit messages for commits that don't change code (documentation updates and such). We use `coverage.py `_ to measures code coverage by tests and upload the result for analyzis to `Coveralls `_ and `Codecov `_: .. image:: https://coveralls.io/repos/github/sqlobject/sqlobject/badge.svg?branch=master :target: https://coveralls.io/github/sqlobject/sqlobject?branch=master .. image:: https://codecov.io/gh/sqlobject/sqlobject/branch/master/graph/badge.svg :target: https://codecov.io/gh/sqlobject/sqlobject Documentation ============= Please write documentation. Documentation should live in the docs/ directory. Pudge converts documentation from Restructured Text to HTML. It presently requires kid 0.9.6, which must be obtained separately (for instance, from https://pypi.python.org/pypi/kid/0.9.6). .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/community.rst0000644000175000017500000000316512752476767016413 0ustar phdphd00000000000000SQLObject Community =================== SQLObject questions and discussion happens on the `sqlobject-discuss mailing list `_. `Gmane `_ also has the list in gmane.comp.python.sqlobject accessible by `HTTP `_, `HTTP (blog format) `_ and `News `_. Bugs should be submitted to the `bug tracker at SourceForge `_ or `GitHub `_, and `patches to the patch tracker `_ (or send pull requests at GitHub). Development takes place in the `git repositories `_. There are `development docs`_. If you are interested in contributing you should read the `Developer Guide `_. There also exists ``##sqlobject`` on the `Freenode IRC Network`_ for development discussions. .. _`development docs`: /devel/ .. _`Freenode IRC Network`: https://freenode.net/ The `Author List `_ tries to list all the major contributors. One can also contribute to `community-editable recipe/documentation site `_. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/Python3.rst0000644000175000017500000000520312752476767015726 0ustar phdphd00000000000000++++++++++++++++++++++ SQLObject and Python 3 ++++++++++++++++++++++ .. contents:: Changes between Python 2 and Python 3 ------------------------------------- There are a few changes in the behaviour of SQLObject on Python 3, due to the changed stings / bytes handling introduced in Python 3.0. BLOBCol ~~~~~~~ In Python 3, BLOBCol now accepts and returns bytes, rather than strings as it did in Python 2. StringCol ~~~~~~~~~ In Python 3, StringCol now accepts arbitrary Unicode strings. UnicodeCol ~~~~~~~~~~ The dbEncoding parameter to UnicodeCol has no effect in Python 3 code. This is now handled by the underlying database layer and is no longer exposed via SQLObject. The parameter is still available for those writing Python 2 compatible code. Python 3 and MySQL ------------------ SQLObject is tested using mysqlclient_ as the database driver on Python 3. Note that the default encoding of MySQL databases is *latin1*, which can cause problems with general Unicode strings. We recommend specifying the character set as *utf8* when using MySQL to protect against these issues. .. _mysqlclient: https://pypi.python.org/pypi/mysqlclient Using databases created with SQLObject and Python 2 in Python 3 --------------------------------------------------------------- For most cases, things should just work as before. The only issues should around UnicodeCol, as how this is handled has changed. SQLite ~~~~~~ The Python 3 sqlite driver expects Unicode columns to be encoded using utf8. Columns created using the default encoding on Python 2 should work fine, but columns created with a different encoding set using the dbEncoding parameter may cause problems. Postgres ~~~~~~~~ Postgres' behaviour is similar to sqlite. Columns created using the default encoding on Python 2 should work fine, but columns created with a different encoding set using the dbEncoding may cause problems. MySQL ~~~~~ For MySQL, the results depend on whether the Python 2 database was using MySQLdb's Unicode mode or not. If a character set was specified for the database using the charset parameter, such as:: mysql:///localhost/test?charset=latin1 Things should work provided the same character set is specified when using Python 3. If a character set wasn't specified, then things may work if the character set is set to match the dbEncoding parameter used when defining the UnicodeCol. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/test.py0000755000175000017500000000044312752476767015165 0ustar phdphd00000000000000#!/usr/bin/env python import doctest import os import sys sys.path.insert( 0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) def test(): for doc in ['SQLObject.rst']: doctest.testfile(doc, optionflags=doctest.ELLIPSIS) if __name__ == '__main__': test() SQLObject-3.1.0/docs/.gitignore0000644000175000017500000000004012753245623015574 0ustar phdphd00000000000000/*.html /_build/ /data.db /html SQLObject-3.1.0/docs/News1.rst0000644000175000017500000003516612752476767015372 0ustar phdphd00000000000000++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 0.6.1 =============== Interface Changes ----------------- * The long broken and unused ``DBMConnection`` has been removed. * Added a connection parameter to all class methods (patch 974755) * Connection objects have a ``.module`` attribute, which points to the DB-API module. This is useful for getting access to the exception objects. Features -------- * New ``UnicodeCol()`` that converts to and from Unicode in the database. See docs_. .. _docs: SQLObject.html#subclasses-of-col * Added indexing (from Jeremy Fitzhardinge). See `the documentation`__ for more. .. __: SQLObject.html#indexes * All connections are explicitly closed, not just garbage collected. Many database drivers don't close database connections properly when the connection object is garbage collected. * New ``distinct`` option to selects, like ``MyClass.select(..., distinct=True)`` * You can now do ``MyClass.selectBy(joinedTable=joinedTableInstance)``, where before you had to do ``MyClass.selectBy(joinedTableID=joinedTableInstance.id)``. (From Dave Cook) SQLObject 0.6 ============= Interface Changes ----------------- * Lazy updates. Add ``_lazyUpdate=True`` to your class, and updates will only be written when you call ``obj.syncUpdate()`` or ``obj.sync()`` (``sync`` also refetches the data from the database, which ``syncUpdate`` does not do). When enabled, instances have a property ``dirty``, which indicates if they have pending updates. Inserts are still done immediately. * Separated database drivers (PostgresConnection, MySQLConnection, etc.) into separate packages. You can access the driver through URIs, like ``mysql://user:pass@host/dbname`` -- to set drivers after class creation you should use `sqlobject.connectionForURI()`. * The ``SQLObject`` package has been renamed to ``sqlobject``. This makes it similar to several other packages, and emphasizes the distinction between the ``sqlobject`` package and the ``SQLObject`` class. * Class instantiation now creates new rows (like `.new()` used to do), and the `.get()` method now retrieves objects that already have rows (like class instantiation used to do). * We're now using a Subversion repository instead of CVS. It is located at http://svn.colorstudy.com/trunk/SQLObject * If you pass ``forceDBName=True`` to the ``*Col`` constructors, then your column name doesn't have to be restricted to a-z, 0-9, and _. * ``*Col`` constructors now support cascade: ``cascade=None`` (default) means no constraint; ``cascade=True`` means that if the foreign key is deleted, the object will be deleted; ``cascade=False`` means that the delete will fail; ``cascade="null"`` means that the column will be set to NULL. The constraints are only implemented in the DBMS, not in SQLObject (i.e., they will not work in databases like MySQL and SQLite). * New ``_create(id, **kw)`` method that can be overridden to intercept and modify attempts to insert rows in the database. * You can specify ``_idType`` in your class, like ``_idType = str``. The default type is ``int``; i.e., IDs are coerced to integers. This is a temporary interface; a more general specifier for primary keys will be added later. * New classmethod ``createTableSQL()`` method for SQLObject classes, which returns the SQL that can be used to create the table. Analog to ``createTable()``. Bugs ---- * SQLite booleans fixed. * You can now use ``sqlite:/:memory:`` to store the database in memory. * Some bugs resolved when caching is turned off (SF 956847) SQLObject 0.5.3 =============== Bugs ---- * Python 2.2 booleans fixed (SF: 903488) * Longs (e.g., ``1L``) get converted properly (SF: 939965) SQLObject 0.5.2 =============== We're now using Subversion instead of CVS. The repository is located at svn://colorstudy.com/trunk/SQLObject Interface Changes ----------------- * If you commit or rollback a transaction, you must call ``trans.begin()`` to restart the transaction. Any database access on the transaction inbetween commit/rollback and being will result in an AssertionError. (It's also acceptable to create a new transaction object instead of reusing the old one, but objects in that transaction will be invalid) Bugs ---- * Using .select() would hold on to a connection, and also release it back to the connection pool. Very un-threadsafe and all-around bad. * Fixed bug which did not release connections after database (query) error. * When setting columns that use validators, the Pythonic (vs. database) representation wasn't being stored in the column. Now we roundtrip (through toPython and fromPython) the values when they get set. * PostgreConnection is back to using sequences for ID generation, instead of oids. Long explanation -- oids can be unindexed in some versions of Postgres, or not even exist. * When turning caching off and using transactions, got an attribute error on rollback. * Rollback or commit didn't find objects that were expired from the cache but still in memory. * Rollback or commit didn't free the connection object, so as you created more transactions it stole connections and didn't put them back in the pool. SQLObject 0.5.1 =============== Released: 12-Nov-2003 Interface Changes ----------------- * Select results no longer have a __len__ method (i.e., you can't do ``len(Person.select(Person.q.firstName=='Bob'))``). There is now a ``.count()`` method instead. ``__len__`` gets called implicitly in several circumstances, like ``list()``, which causes potentially expensive queries to ``COUNT(*)``. Bugs ---- * Objects retrieved from a join now respect the transaction context of the original instance. * ``.select().reversed()`` works. SQLObject 0.5 ============= Released: 1-Nov-2003 Features -------- * Firebird_ support. * Database-specific literal quoting (motivation: MySQL and Postgres use backslashes, Firebird and SQLite do not). * Generic conversion/validation can be added to columns. * BoolCol for portable boolean columns (BOOL on Postgres, INT on MySQL, etc.) * Non-integer IDs. (Automatic table creation is not supported for non-integer IDs) * Explicit IDs for new instances/rows (required for non-integer IDs). * Instances can be synced with the database (in case there have been updates to the object since it was first fetched). * Instances can be expired, so that they will be synced when they are next accessed. .. _Firebird: http://firebird.sourceforge.net/ Interface Changes ----------------- * `SQLBuilder.sqlRepr` renamed to `SQLBuilder.sqlrepr`, signature changed to ``sqlrepr(value, databaseName)`` to quote ``value``, where ``databaseName`` is one of ``"mysql"``, ``"postgres"``, ``"sqlite"``, ``"firebird"``. * ``sqlRepr`` magic method renamed to ``__sqlrepr__``, and takes new ``databaseName`` argument. * When using explicit booleans, use ``Col.TRUE`` and ``Col.FALSE`` for backward compatibility with Python 2.2. This is not required for ``BoolCol``, however (which converts all true values to TRUE and false values to FALSE) * SQLObject has a ``sqlrepr`` method, so you can construct queries with something like ``"WHERE last_name = %s" % Person.sqlrepr('Bob')`` Bugs ---- * Released all locks with ``finally:``, so that bugs won't cause frozen locks. * Tons of transaction fixes. Transactions pretty much work. * A class can have multiple foreign keys pointing to the same table (e.g., ``spouse = ForeignKey("Person"); supervisor = ForeignKey("Person")``) SQLObject 0.4 ============= Features -------- * You can specify columns in a new, preferred manner:: class SomeObject(SQLObject): someColumn = Col() Equivalent to:: class SomeObject(SQLObject): _columns = [Col('someColumn')] Ditto joins. * Cache objects have a clear method, which empties all objects. However, weak references to objects *are* maintained, so the integrity of the cache can be ensured. * SQLObject subclasses can be further subclassed, adding or removing column definitions (as well as changing settings like connection, style, etc). Each class still refers to a single concrete table in the database -- the class hierarchy is not represented in the database. * Each SQLObject subclass can have an associated style, as given in the `_style` attribute. This object is used to map between Python and database names (e.g., the column name for a Python attribute). Some samples are available in the `Style` module. * Postgres support for `_fromDatabase` (reading a table definition from the database, and creating a class from that). * Postgres id columns more permissive, you don't have to create a specially named sequence (or implicitly create that sequence through ``SERIAL``). lastoid is used instead. * MySQL uses ``localhost`` as the default host, and the empty string as the default password. * Added functions for use with queries: `ISNULL`, `ISNOTNULL`. ``==`` and ``!=`` can be used with None, and is translated into `ISNULL`, `ISNOTNULL`. * Classes can be part of a specific registry. Since classes are referred to by name in several places, the names have to be unique. This can be problematic, so you can add a class variable `_registry`, the value of which should be a string. Classes references are assumed to be inside that registry, and class names need only be unique among classes in that registry. * ``SomeClass.select()`` selects all, instead of using ``SomeClass.select('all')``. You can also use None instead of ``'all'``. * Trying to fetch non-existent objects raises `SQLObjectNotFound`, which is a subclass of the builtin exception `LookupError`. This may not be raised if `_cacheValues` is False and you use the ID to fetch an object (but alternateID fetches will raise the exception in either case). * Can order by descending order, with the `reversed` option to the `select` method, or by prefixing the column with a ``"-"``. * Ordering with joins works better -- you can order with multiple columns, as well as descending ordering. Col and Join ~~~~~~~~~~~~ * `Join` constructors have an argument `orderBy`, which is the name of a Python attribute to sort results by. If not given, the appropriate class's `_defaultOrder` will be used. None implies no sorting (and ``orderBy=None`` will override `_defaultOrder`). * `ForeignKey` class (subclass of `Col`), for somewhat easier/clearer declaration of foreign keys. * `Col` (and subclasses) can take a `sqlType` argument, which is used in table definitions. E.g., ``Col(sqlType="BOOLEAN")`` can be used to create a ``BOOLEAN`` column, even though no `BooleanCol` exists. * `alternateID` (a specifier for columns) implies ``NOT NULL``. Also implies ``UNIQUE``. * `unique` (a specifier for columns) added. * `DecimalCol` and `CurrencyCol` added. * `EnumCol` uses constraints on Postgres (if you use `createTable`). Bugs ---- * `DateTimeCol` uses ``TIMESTAMP`` for Postgres. Note that the Python type name is used for column names, not necessarily the SQL standard name. * Foreign key column names are slightly more permissive. They still need to end in ``id``, but it's case insensitive. * _defaultOrder should be the python attribute's name, not the database name. * SomeClass.q.colName uses proper Python attributes for colName, and proper database names when executed in the database. * SQLite select results back to being proper iterator. * SomeClass.q.colName now does proper translation to database names, using dbName, etc., instead of being entirely algorithm-driven. * Raise `TypeError` if you pass an unknown argument to the `new` method. * You can override the _get_* or _set_* version of a property without overriding the other. * Python 2.3 compatible. * Trying to use ``Col('id')`` or ``id = Col()`` will raise an exception, instead of just acting funky. * ``ForeignKey`` columns return None if the associated column is NULL in the database (used to just act weird). * Instantiating an object with an id of None will give an error, instead of just acting weird. Internal -------- * `Col` class separated into `Col` and `SOCol` (and same for all other `*Col` classes). `Col` defines a column, `SOCol` is that definition bound to a particular SQLObject class. * Instance variable ``_SO_columns`` holds the `SOCol` instances. SQLObject 0.3 ============= Features -------- * Table creation (SQL schema generation) via new class method `createTable`. And of course a `dropTable` method to go with. * Add and remove columns at runtime, optionally modifying the schema in the database (via ``ALTER``). (Does not work in SQLite) * New column classes (see `Col` module), indicates type * Classes can be created by parsing an already existant table (MySQL only). * Objects are not cached indefinitely. Cached objects are expired into a weak dictionary (it allows objects to be garbage collected if nowhere else in the program is using the object, but until it is collected it's still available to the cache). Some cache control, pass ``nocache=True`` to your connection object to eliminate as much caching as possible. See `Cache` module for a bit more. * New DBMConnection, implements a database-like backend without any database to speak of, including queries (so long as you use `SQLBuilder` and don't generate your where clauses manually). Actual SQL generation is done entirely by the database connection, allowing portability across very different backends. * Postgres table IDs should be created with type ``SERIAL`` (which implicitly creates a sequence). * New `_defaultOrder` class variable gives a default for the `orderBy` parameter to `select` queries. Bugs ---- * LIMIT/OFFSET (select result slicing) works in Postgres and SQLite. * ``tableExists`` method from DBConnection works in same. * mxDateTime not required (never should have been, always just an option). SQLObject 0.2.1 =============== Bugs ---- * Fixed caching of new objects Features -------- * SQLite_ support * Select statements are lazily generated, retrieve full rows for speed, and are slicable (`select docs`_). * `alternateID` option for `Col` objects -- select individual objects via UNIQUE columns, e.g., a username (`Col docs`_). .. _SQLite: http://sqlite.org/ .. _select docs: SQLObject.html#selecting-multiple-objects .. _Col docs: SQLObject.html#col-class-specifying-columns .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/SelectResults.rst0000644000175000017500000001533612752476767017173 0ustar phdphd00000000000000SelectResults: Using Queries ============================ .. contents:: Contents: Overview -------- SelectResults are returned from ``.select`` and ``.selectBy`` methods on SQLObject classes, and from ``SQLMultipleJoin``, and ``SQLRelatedJoin`` accessors on SQLObject instances. Select results are generators, which are lazily evaluated. The SQL is only executed when you iterate over the select results, fetching rows one at a time. This way you can iterate over large results without keeping the entire result set in memory. You can also do things like ``.reversed()`` without fetching and reversing the entire result -- instead, SQLObject can change the SQL that is sent so you get equivalent results. .. note:: To retrieve the results all at once use the python idiom of calling ``list()`` on the generator to force execution and convert the results to a stored list. You can also slice select results. This modifies the SQL query, so ``peeps[:10]`` will result in ``LIMIT 10`` being added to the end of the SQL query. If the slice cannot be performed in the SQL (e.g., peeps[:-10]), then the select is executed, and the slice is performed on the list of results. This will generally only happen when you use negative indexes. In certain cases, you may get a select result with an object in it more than once, e.g., in some joins. If you don't want this, you can add the keyword argument ``MyClass.select(..., distinct=True)``, which results in a ``SELECT DISTINCT`` call. You can get the length of the result without fetching all the results by calling ``count`` on the result object, like ``MyClass.select().count()``. A ``COUNT(*)`` query is used -- the actual objects are not fetched from the database. Together with slicing, this makes batched queries easy to write:: start = 20 size = 10 query = Table.select() results = query[start:start+size] total = query.count() print "Showing page %i of %i" % (start/size + 1, total/size + 1) .. note:: There are several factors when considering the efficiency of this kind of batching, and it depends very much how the batching is being used. Consider a web application where you are showing an average of 100 results, 10 at a time, and the results are ordered by the date they were added to the database. While slicing will keep the database from returning all the results (and so save some communication time), the database will still have to scan through the entire result set to sort the items (so it knows which the first ten are), and depending on your query may need to scan through the entire table (depending on your use of indexes). Indexes are probably the most important way to improve importance in a case like this, and you may find caching to be more effective than slicing. In this case, caching would mean retrieving the *complete* results. You can use ``list(MyClass.select(...))`` to do this. You can save these results for some limited period of time, as the user looks through the results page by page. This means the first page in a search result will be slightly more expensive, but all later pages will be very cheap. Retrieval Methods ----------------- Iteration ~~~~~~~~~ As mentioned in the overview, the typical way to access the results is by treating it as a generator and iterating over it (in a loop, by converting to a list, etc). ``getOne(default=optional)`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In cases where your restrictions cause there to always be a single record in the result set, this method will return it or raise an exception: SQLObjectIntegrityError if more than one result is found, or SQLObjectNotFound if there are actually no results, unless you pass in a default like ``.getOne(None)``. Cloning Methods --------------- These methods return a modified copy of the SelectResult instance they are called on, so successive calls can chained, eg ``results = MyClass.selectBy(city='Boston').filter(MyClass.q.commute_distance>10).orderBy('vehicle_mileage')`` or used independently later on. ``orderBy(column)`` ~~~~~~~~~~~~~~~~~~~ Takes a string column name (optionally prefixed with '-' for DESCending) or a `SQLBuilder expression`_. ``limit(num)`` ~~~~~~~~~~~~~~ Only return first num many results. Equivalent to results[:num] slicing. ``lazyColumns(v)`` ~~~~~~~~~~~~~~~~~~ Only fetch the IDs for the results, the rest of the columns will be retrieved when attributes of the returned instances are accessed. ``reversed()`` ~~~~~~~~~~~~~~ Reverse-order. Alternative to calling orderBy with SQLBuilder.DESC or '-'. ``distinct()`` ~~~~~~~~~~~~~~ In SQL, SELECT DISTINCT, removing duplicate rows. ``filter(expression)`` ~~~~~~~~~~~~~~~~~~~~~~ Add additional expressions to restrict result set. Takes either a string static SQL expression valid in a WHERE clause, or a `SQLBuilder expression`_. ANDed with any previous expressions. .. _`SQLBuilder expression`: SQLBuilder.html Aggregate Methods ----------------- These return column values (strings, numbers, etc) not new SQLResults instances, by making the appropriate SQL query (the actual result rows are not retrieved). Any that take a column can also take a SQLBuilder column instance, e.g. ``MyClass.q.size``. ``count()`` ~~~~~~~~~~~ Returns the length of the result set, by a SQL ``SELECT COUNT(...)`` query. ``sum(column)`` ~~~~~~~~~~~~~~~ The sum of values for ``column`` in the result set. ``min(column)`` ~~~~~~~~~~~~~~~ The minimum value for ``column`` in the result set. ``max(column)`` ~~~~~~~~~~~~~~~ The maximum value for ``column`` in the result set. ``avg(column)`` ~~~~~~~~~~~~~~~ The average value for the ``column`` in the result set. Traversal to related SQLObject classes -------------------------------------- ``throughTo.join_name and throughTo.foreign_key_name`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This accessor lets you retrieve the objects related to your SelectResults by either a join or foreign key relationship, in the same manner as the cloning methods above. For instance:: Schools.select(Schools.q.student_satisfaction>90).throughTo.teachers returns a SelectResult of Teachers of Schools with satisfied students, assuming Schools has a SQLMultipleJoin or SQLRelatedJoin attribute named ``teachers``. Similarily, with a self-joining foreign key named ``father``:: Person.select(Person.q.name=='Steve').throughTo.father.throughTo.father returns a SelectResult of Persons who are the paternal grandfather of someone named ``Steve``. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/News2.rst0000644000175000017500000003725012752476767015367 0ustar phdphd00000000000000++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 0.8.7 =============== Released 10 Jan 2008. * A number of changes ported from `SQLObject 0.7.10`_. SQLObject 0.8.6 =============== Released 30 Oct 2007. * Removed SelectResults.__nonzero__, which was a design mistake. Raising an exception in __nonzero__() is inconsistent with other iterators (bool(iter([])) => True). * A number of changes ported from `SQLObject 0.7.9`_. SQLObject 0.8.5 =============== Released 25 July 2007. Bug Fixes --------- * Suppress the second RowUpdateSignal in .set() called from ._SO_setValue(). SQLObject 0.8.4 =============== Released 10 May 2007. Bug Fixes --------- * A number of bugfixes forward-ported from 0.7.7. SQLObject 0.8.3 =============== Released 3 May 2007. Bug Fixes --------- * A number of bugfixes forward-ported from 0.7.6. SQLObject 0.8.2 =============== Released 11 Apr 2007. Bug Fixes --------- * Fixed ConnectionHub.doInTransaction() - if the original connection was processConnection - reset processConnection, not threadConnection. SQLObject 0.8.1 =============== Released 19 Mar 2007. Bug Fixes --------- * ID columns are reverted back from INT UNSIGNED to INT for MySQL to be in accord with FOREIGN KEYs. * Fixed return value from Firebird/MaxdbConnection.createTable(). * Fixed and simplified DatabaseIndex.get(). * Fixed ConnectionHub.doInTransaction() - close low-level connection on commit() to prevent connections leaking. SQLObject 0.8.0 =============== Released 12 Feb 2007. Features & Interface -------------------- * It is now possible to create tables that reference each other. Constraints (in the DBMSes that support constraints) are added after the tables have been created. * Added ``createSQL`` as an option for sqlmeta. Here you can add related SQL you want executed by sqlobject-admin create after table creation. createSQL expects a string, list, or dictionary. If using a dictionary the key should be a dbName value (ex. 'postgres') and the value should be a string or list. Examples in sqlobject/tests/test_sqlobject_admin.py or at * Added method ``sqlhub.doInTransaction(callable, *args, **kwargs)``, to be used like:: sqlhub.doInTransaction(process_request, os.environ) This will run ``process_request(os.environ)``. The return value will be preserved. * Added method ``.getOne([default])`` to ``SelectResults`` (these are the objects returned by ``.select()`` and ``.selectBy()``). This returns a single object, when the query is expected to return only one object. The single argument is the value to return when zero results are found (more than one result is always an error). If no default is given, it is an error if no such object exists. * Added a WSGI middleware (in ``sqlobject.wsgi_middleware``) for configuring the database for the request. Also handles transactions. Available as ``egg:SQLObject`` in Paste Deploy configuration files. * New joins! ManyToMany and OneToMany; not fully documented yet, but still more sensible and smarter. * SELECT FOR UPDATE * New module dberrors.py - a hierarchy of exceptions. Translation of DB API module's exceptions to the new hierarchy is performed for SQLite and MySQL. * SQLiteConnection got a new keyword "factory" - a name or a reference to a factory function that returns a connection class; useful for implementing functions or aggregates. See test_select.py and test_sqlite_factory.py for examples. * SQLObject now disallows columns with names that collide with existing variables and methods, such as "_init", "expire", "set" and so on. Small Features -------------- * Configurable client character set (encoding) for MySQL. * Added a close option to .commit(), so you can close the transaction as you commit it. * DecimalValidator. * Added .expireAll() methods to sqlmeta and connection objects, to expire all instances in those cases. * String IDs. * FOREIGN KEY for MySQL. * Support for sqlite3 (a builtin module in Python 2.5). * SelectResults cannot be queried for truth value; in any case it was meaningless - the result was always True; now __nonzero__() raises NotImplementedError in case one tries bool(MyTable.select()) or "if MyTable.select():..." * With empty parameters AND() and OR() returns None. * Allows to use set/frozenset sets/Set/ImmutableSet sets as sequences passed to the IN operator. * ID columns are now INT UNSIGNED for MySQL. Bug Fixes --------- * Fixed problem with sqlite and threads; connections are no longer shared between threads for sqlite (except for :memory:). * The reference loop between SQLObject and SQLObjectState eliminated using weak references. * Another round of bugfixes for MySQL errors 2006 and 2013 (SERVER_GONE, SERVER_LOST). * Fixed a bug in MSSQLConnection caused by column names being unicode. * Fixed a bug in FirebirdConnection caused by column names having trailing spaces. * Order by several columns with inheritance. * Fixed aggregators and accumulators with inheritance. SQLObject 0.7.10 ================ Released 10 Jan 2008. * With PySQLite2 do not use encode()/decode() from PySQLite1 - always use base64 for BLOBs. * MySQLConnection doesn't convert query strings to unicode (but allows to pass unicode query strings if the user build ones). DB URI parameter sqlobject_encoding is no longer used. SQLObject 0.7.9 =============== Released 30 Oct 2007. Bug Fixes --------- * Remove 'limit' from SelectResults after setting start/end so .clone() never sees limit again. * Fixed a bug in sqlbuilder._LikeQuoted() - call sqlrepr() on the expression to escape single quotes if the expression is a string. * Fixed StringCol and UnicodeCol: use sqlType with MSSQL. * Fixed startswith/endswith/contains for UnicodeCol. Other Changes ------------- * Changed the default value for 'varchar' in BLOBColumns from 'auto' to False (so that the default type for the columns in MySQL is BLOB, not TEXT). * Changed the implementation type in BoolCol under MySQL from TINYINT to BOOL (which is a synonym for TINYINT(1)). SQLObject 0.7.8 =============== Released 25 July 2007. Bug Fixes --------- * Replaced calls to style.dbColumnToPythonAttr() in joins.py by name/dbName lookup in case the user named columns differently using dbName. * Minor correction in the tests: we fully support EnumCol in Postgres. * MySQLConnection now recognizes Enum, Double and Time columns when drawing the database scheme from DB. * Minor fix in FirebirdConnection.fromDatabase. * Fixed a bug with default field values for columns for Firebird connection. * Fixed a bug in col.createSQL(). * Fixed a bug in converting date/time for years < 1000 (time.strptime() requires exactly 4 digits for %Y, hence a year < 1000 must be 0-padded). Other Changes ------------- * Changed string quoting style for PostgreSQL and MySQL from \\' to ''. SQLObject 0.7.7 =============== Released 10 May 2007. Bug Fixes --------- * Fixed a bug in SQLRelatedJoin that ignored per-instance connection. * Fixed a bug in MySQL connection in case there is no charset in the DB URI. SQLObject 0.7.6 =============== Released 3 May 2007. Bug Fixes --------- * Fixed a longstanding bug with .select() ignoring 'limit' parameter. * Fixed a bug with absent comma in JOINs. * Fixed sqlbuilder - .startswith(), .endswith() and .contains() assumed their parameter must be a string; now you can pass an SQLExpression: Table.q.name.contains(func.upper('a')), for example. * Fixed a longstanding bug in sqlbuilder.Select() with groupBy being a sequence. * Fixed a bug with Aliases in JOINs. * Yet another patch to properly initialize MySQL connection encoding. * Fixed a minor comparison problem in test_decimal.py. * More documentation about orderBy. SQLObject 0.7.5 =============== Released 11 Apr 2007. Bug Fixes --------- * Fixed test_deep_inheritance.py - setup classes in the correct order (required for Postgres 8.0+ which is strict about referential integrity). * Fixed a bug in DateValidator caused by datetime being a subclass of date. SQLObject 0.7.4 =============== Released 19 Mar 2007. Small Features -------------- * For MySQLdb 1.2.2+ call ping(True) on the connection to allow autoreconnect after a timeout. Bug Fixes --------- * Another round of changes to create/drop the tables in the right order in the command-line client `sqlobject-admin`. * Fixed a bug in UnicodeField - allow comparison with None. SQLObject 0.7.3 =============== Released 30 Jan 2007. Bug Fixes --------- * Allow multiple MSSQL connections. * Psycopg1 requires port to be a string; psycopg2 requires port to be an int. * Fixed a bug in MSSQLConnection caused by column names being unicode. * Fixed a bug in FirebirdConnection caused by column names having trailing spaces. * Fixed a missed import in firebirdconnection.py. * Remove a leading slash in FirebirdConnection. * Fixed a bug in deep Inheritance tree. SQLObject 0.7.2 =============== Released 20 Nov 2006. Features & Interface -------------------- * sqlbuilder.Select now supports JOINs exactly like SQLObject.select. * destroySelf() removes the object from related joins. Bug Fixes --------- * Fixed a number of unicode-related problems with newer MySQLdb. * If the DB API driver returns timedelta instead of time (MySQLdb does this) it is converted to time; but if the timedelta has days an exception is raised. * Fixed a number of bugs in InheritableSQLObject related to foreign keys. * Fixed a bug in InheritableSQLObject related to the order of tableRegistry dictionary. * A bug fix that allows to use SQLObject with DateTime from Zope. Documentation Added ------------------- * Added "How can I define my own intermediate table in my Many-to-Many relationship?" to FAQ. SQLObject 0.7.1 =============== Released 25 Sep 2006. Features & Interface -------------------- * Added support for psycopg2_ .. _psycopg2: http://initd.org/projects/psycopg2 * Added support for MSSQL. * Added ``TimeCol``. * ``RelatedJoin`` and ``SQLRelatedJoin`` objects have a ``createRelatedTable`` keyword argument (default ``True``). If ``False``, then the related table won't be automatically created; instead you must manually create it (e.g., with explicit SQLObject classes for the joins). * Implemented ``RLIKE`` (regular expression LIKE). * Moved _idSequence to sqlmeta.idSequence. Small Features -------------- * Select over RelatedJoin. * SQLite foreign keys. * Postgres DB URIs with a non-default path to unix socket. * Allow the use of foreign keys in selects. * Implemented addColumn() for SQLite. * With PySQLite2 use encode()/decode() from PySQLite1 for BLOBCol if available; else use base64. Bug Fixes --------- * Fixed a longstanding problem with UnicodeCol - at last you can use unicode strings in .select() and .selectBy() queries. There are some limitations, though; see the description of the UnicodeCol_. .. _UnicodeCol: SQLObject.html#column-types * Cull patch (clear cache). * .destroySelf() inside a transaction. * Synchronize main connection cache during transaction commit. * Ordering joins with NULLs. * Fixed bugs with plain/non-plain setters. * Lots of other bug fixes. SQLObject 0.7.0 =============== Features & Interface -------------------- * Inheritance. See Inheritance.html_ .. _Inheritance.html: Inheritance.html * Date/time validators, converters, tests. * Both `mxDateTime `_ and `datetime `_ supported for ``DateTimeCol``. * Added ``BLOBCol``, for binary data. * Added ``PickleCol``, to transparently pickle and unpickle data from column. * New `documented reflection interface `_, using the new ``.sqlmeta`` class/instance. Most special attributes that started with ``_`` were moved into ``sqlmeta`` (with leading underscore removed). * New aggregate functions for select results, like ``cls.select().max(columnName)``: ``.max()``, ``.min()``, ``.avg()``. * ``ConnectionHub`` aka ``sqlhub`` (@@: Needs documentation) * Command-line client `sqlobject-admin `_. * ``StringCol`` has ``char_binary`` attribute, for explicit case handling in MySQL. * Various joins now supported (LEFT, RIGHT, STRAIGHT, INNER, OUTER, CROSS): see `documentation `_. Aliases for joining a table with itself. * Subqueries/subselects (`see docs `_). * Select results support ``.filter(extra_query)`` * ``SQLMultipleJoin`` and ``SQLRelatedJoin``, like ``MultipleJoin`` and ``RelatedJoin``, except return select results (@@: Document). * `SingleJoin `_. * Columns retain their order from the class definition to table creation. * SQLObject now depends on the `FormEncode `_ library, and internal conversion/validation is done through FormEncode (was previously using old fork of FormEncode). * Column instances can have attributes set on them (generally for annotating columns with extra data). Other Changes ------------- * When iterating over select results, a list is now immediately created with the full list of instances being selected. Before instances were created on demand, as select results were pulled out row-by-row. The previous lazy behavior is available with the method ``lazyIter``, used like ``for obj in MyClass.select().lazyIter(): ...``. * Test framework now uses `py.test `_. * SQLObject now uses a simpler metaclass (``sqlobject.declarative.DeclarativeMeta``). * autoCommit and queryIns ?? (@@: expand) * Deprecation (@@: document) * Use `setuptools `_ for packaging and installation. Small Features -------------- * ``IntValidator`` for testing ``IntCol`` inputs. * Base style (``sqlobject.styles.Style``) is now a usable no-op style. * SQLite in-memory databases allowed with ``sqlite:/:memory:`` * Keyword parameters allowed to ``connectionForURI`` (like ``debug=True``). * More parameters passed to MySQL connections (unix_socket, named_pipe, init_command, read_default_file, read_default_group, connect_time, compress, named_pipe, use_unicode, client_flag, local_infile). * ``DateTimeCol.now`` is a function for producing the current date, using whatever date/time module you are using (good for use as a default). * Inherited classes fetched more efficiently (fewer queries). * Decimal converter to create `decimal objects `_. * Repository rearranged (now in ``http://svn.colorstudy.com/SQLObject/trunk``). Bug Fixes --------- * Tables with no columns can work. Why would you have a table without a column? We do not know, we try only to serve. * Sybase ``_fromDatabase`` fixed. * Various fixes to support most recent ``MySQLdb`` adapter, and ``pysqlite`` adapters. * URI parsing improved, including Windows paths (for use with SQLite). * ``selectBy(column=None)`` creates ``IS NULL`` query. * ``selectBy(foreignKey=value)`` now supported (not just selecting by foreign key ID). * ``cascade='null'`` wasn't working properly (was cascading all deletes, not nullifying!). * Lots of other bug fixes. `Older news`__ .. __: News1.html .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/rebuild0000755000175000017500000000124412752476767015205 0ustar phdphd00000000000000#! /bin/sh here=`pwd` parent=`dirname "$here"` echo "Adding $parent to \$PYTHONPATH" PYTHONPATH="$parent${PYTHONPATH:+:$PYTHONPATH}" export PYTHONPATH NORMAL="Authors DeveloperGuide FAQ Inheritance News News1 News2 News3 News4 News5 Python3 SQLBuilder SQLObject SelectResults TODO Versioning Views community download index links sqlobject-admin" for NAME in $NORMAL ; do if [ -e "$NAME.html" -a ! "$NAME.html" -ot "$NAME.rst" ] ; then echo "$NAME is up to date." continue fi echo "Building $NAME." rst2html.py --no-toc-backlinks --stylesheet=default.css --link-stylesheet \ -- "$NAME.rst" > "$NAME.html" done SQLObject-3.1.0/docs/News.rst0000644000175000017500000000332212754656750015270 0ustar phdphd00000000000000++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 3.1.0 =============== Released 16 Aug 2016. Features -------- * Add UuidCol. * Add JsonbCol. Only for PostgreSQL. Requires psycopg2 >= 2.5.4 and PostgreSQL >= 9.2. * Add JSONCol, a universal json column. * For Python >= 3.4 minimal FormEncode version is now 1.3.1. * If mxDateTime is in use, convert timedelta (returned by MySQL) to mxDateTime.Time. Documentation ------------- * Developer's Guide extended to explain SQLObject architecture and how to create a new column type. * Fix URLs that can be found; remove missing links. * Rename reStructuredText files from \*.txt to \*.rst. Source code ----------- * Fix all `import *` using https://github.com/zestyping/star-destroyer. Tests ----- * Tests are now run at Circle CI. * Use pytest-cov for test coverage. Report test coverage via coveralls.io and codecov.io. * Install mxDateTime to run date/time tests with it. SQLObject 3.0.0 =============== Released 1 Jun 2016. Features -------- * Support for Python 2 and Python 3 with one codebase! (Python version >= 3.4 currently required.) Minor features -------------- * PyDispatcher (>=2.0.4) was made an external dependency. Development ----------- * Source code was made flake8-clean. Documentation ------------- * Documentation is published at http://sqlobject.readthedocs.org/ in Sphinx format. `Older news`__ .. __: News5.html .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/News3.rst0000644000175000017500000002550512752476767015370 0ustar phdphd00000000000000++++ News ++++ .. contents:: Contents: :backlinks: none .. _start: SQLObject 0.10.9 ================ * The cache culling algorithm was enhanced to eliminate memory leaks by removing references to dead objects; tested on a website that runs around 4 million requests a day. SQLObject 0.10.8 ================ Released 30 Sep 2009. * Fixed a bug in logging to console - convert unicode to str. * Fixed an obscure bug in ConnectionHub triggered by an SQLObject class whose instances can be coerced to boolean False. SQLObject 0.10.7 ================ Released 20 Sep 2009. * Fixed a bug: Sybase tables with identity column fire two identity_inserts. * Fixed a bug: q.startswith(), q.contains() and q.endswith() escape (with a backslash) all special characters (backslashes, underscores and percent signs). SQLObject 0.10.6 ================ Released 18 May 2009. * Better support for Python 2.6: do not import the deprecated sets module. * A number of changes ported from `SQLObject 0.9.11`_. SQLObject 0.10.5 ================ Released 6 May 2009. * A number of changes ported from `SQLObject 0.9.10`_. * sqlmeta.getColumns() becomes classmethod. SQLObject 0.10.4 ================ Released 8 Dec 2008. * Fixed createSQL constrains generation under MySQL when the table's name includes the database's name (contains a dot). SQLObject 0.10.3 ================ Released 1 Dec 2008. * A number of changes ported from `SQLObject 0.9.8`_. SQLObject 0.10.2 ================ Released 30 May 2008. * A number of changes ported from `SQLObject 0.9.7`_. SQLObject 0.10.1 ================ Released 4 May 2008. * Fixed a bug: limit doesn't work in sqlbuilder.Select. * A number of changes ported from `SQLObject 0.9.6`_. SQLObject 0.10.0 ================ Released 11 Mar 2008. Features & Interface -------------------- * Dropped support for Python 2.2. The minimal version of Python for SQLObject is 2.3 now. * Removed actively deprecated attributes; lowered deprecation level for other attributes to be removed after 0.10. * SQLBuilder Select supports the rest of SelectResults options (reversed, distinct, joins, etc.) * SQLObject.select() (i.e., SelectResults) and DBConnection.queryForSelect() use SQLBuilder Select queries; this make all SELECTs implemented internally via a single mechanism. * SQLBuilder Joins handle SQLExpression tables (not just str/SQLObject/Alias) and properly sqlrepr. * Added SQLBuilder ImportProxy. It allows one to ignore the circular import issues with referring to SQLObject classes in other files - it uses the classregistry as the string class names for FK/Joins do, but specifically intended for SQLBuilder expressions. See tests/test_sqlbuilder_importproxy.py. * Added SelectResults.throughTo. It allows one to traverse relationships (FK/Join) via SQL, avoiding the intermediate objects. Additionally, it's a simple mechanism for pre-caching/eager-loading of later FK relationships (i.e., going to loop over a select of somePeople and ask for aPerson.group, first call list(somePeople.throughTo.group) to preload those related groups and use 2 db queries instead of N+1). See tests/test_select_through.py. * Added ViewSQLObject. * Added sqlmeta.getColumns() to get all the columns for a class (including parent classes), excluding the column 'childName' and including the column 'id'. sqlmeta.asDict() now uses getColumns(), so there is no need to override it in the inheritable sqlmeta class; this makes asDict() to work properly on inheritable sqlobjects. * Allow MyTable.select(MyTable.q.foreignKey == object) where object is an instance of SQLObject. * Added rich comparison methods; SQLObjects of the same class are considered equal is they have the same id; other methods return NotImplemented. * RowDestroySignal is sent on destroying an SQLObject instance; postfunctions are run after the row has been destroyed. * Changed the implementation type in BoolCol under SQLite from TINYINT to BOOLEAN and made fromDatabase machinery to recognize it. * MySQLConnection (and DB URI) accept a number of SSL-related parameters: ssl_key, ssl_cert, ssl_ca, ssl_capath. * Use sets instead of dicts in tablesUsed. Dropped tablesUsedDict function; instead there is tablesUsedSet that returns a set of strings. * SQLBuilder tablesUsedSet handles sqlrepr'able objects. * Under MySQL, PickleCol no longer used TEXT column types; the smallest column is now BLOB - it is not possible to create TINYBLOB column. SQLObject 0.9.11 ================ Released 18 May 2009. * Two bugs in SQLiteConnection.columnsFromSchema() were fixed: use sqlmeta.idName instead of 'id'; convert default 'NULL' to None. * Use sqlmeta.idName instead of 'id' in all connection classes. * Fixed a bug that prevented to override per class _connection if there is sqlhub.processConnection. SQLObject 0.9.10 ================ Released 6 May 2009. * Another unicode-related patch for MySQL; required because different versions of MySQLdb require different handling:: - MySQLdb < 1.2.1: only ascii - MySQLdb = 1.2.1: only unicode - MySQLdb > 1.2.1: both ascii and unicode * Setup requires FormEncode version 1.1.1+. * A minor bug was fixed in creating a DecimalValidator - pass the column name to it. * A bug was fixed in InheritableIteration - pass connection to child klass.select(). * A bug was fixed in PostgresConnection.columnsFromSchema() - foreign keys are now recognized and created as proper ForeignKey with correct column name and table name. * Bugs in PostgresConnection and MSSQLConnection related to properties was fixed. A note for developers: from now on properties in DBConnection classes are forbidden as they don't work with Transaction - Transaction.__getattr__() cannot properly wrap 'self' so a property is called with wrong 'self'. * Transaction instances now explicitly raises TypeError on close() - without this calling Transaction.close() calls connection.close() which is wrong. * A bug in SQLiteConnection.columnsFromSchema() that led to an infinite loop was fixed. SQLObject 0.9.9 =============== * Backported from the trunk: under MySQL use the connection's dbEncoding instead of ascii, when converting a unicode value from python to database for a StringCol. SQLObject 0.9.8 =============== Released 1 Dec 2008. * Changed interpretation of strings in the DB URI for boolean parameters: '0', 'no', 'off' and 'false' are now interpreted as False. * Fixed a bug with incorrect handling of calls like connectionForURI(dburi, cache=False) when dburi already contains some parameters in the URI. * Convert decimal.to_eng_string() to str to work around a bug in Python 2.5.2; see https://mail.python.org/pipermail/python-dev/2008-March/078189.html * Added test_default_style.py. * Fixed a minor bug in SQLiteConnection that fails to parse Enum columns. SQLObject 0.9.7 =============== Released 30 May 2008. Small Features -------------- * Use VARCHAR(MAX) and VARBINARY(MAX) for MSSQL >= 9.0. * Run post_funcs after RowDestroySignal. Bug Fixes --------- * Fixed a minor bug in Set column. * A bug fixed for RowCreatedSignal together with InheritableSQLObject: run post_funcs after the entire hierarchy has been created. * Aggregate functions now honors 'distinct'. SQLObject 0.9.6 =============== Released 4 May 2008. * A bug in inheritable delColumn() that doesn't remove properties was fixed. * A minor bug was fixed in col.py - the registry must be passed to findClass(). * Reverted the patch declarative.threadSafeMethod() - it causes more harm then good. SQLObject 0.9.5 =============== Released 10 Mar 2008. * Fixed a minor bug in SQLiteConnection.columnsFromSchema() - set dbName. * A bug in delColumn() that removes all properties was fixed by recreating properties. SQLObject 0.9.4 =============== Released 3 Mar 2008. * Use list.reverse() in manager/command.py for Python 2.2 compatibility. * Prevent MultipleJoin from removing the intermediate table if it was not created by the Join. * Fixed a bug with no default when defaultSQL is defined for the column. * Recognize POINT data type as string in PostgresConnection.columnsFromSchema(). SQLObject 0.9.3 =============== Released 10 Jan 2008. * A number of changes ported from SQLObject 0.7.10. SQLObject 0.9.2 =============== Released 30 Oct 2007. * Fixed a bug in Versioning - do not copy "alternateID" and "unique" attributes from the versioned table. * Fixed a misspelled 'zerofill' option's name. * Fixed bugs in SQLiteConnection.guessColumn(). * A number of changes ported from SQLObject 0.7.9 and SQLObject 0.8.6. SQLObject 0.9.1 =============== Released 25 July 2007. Bug Fixes --------- * Fixed misspelled methods in col.py. * A number of bugfixes ported from SQLObject 0.7.8 and SQLObject 0.8.5. SQLObject 0.9.0 =============== Released 10 May 2007. Features & Interface -------------------- * Support for Python 2.2 has been declared obsolete. * Removed actively deprecated attributes; lowered deprecation level for other attributes to be removed after 0.9. * SQLite connection got columnsFromSchema(). Now all connections fully support fromDatabase. There are two version of columnsFromSchema() for SQLite - one parses the result of "SELECT sql FROM sqlite_master" and the other uses "PRAGMA table_info"; the user can choose one over the other by using "use_table_info" parameter in DB URI; default is False as the pragma is available only in the later versions of SQLite. * Changed connection.delColumn(): the first argument is sqlmeta, not tableName (required for SQLite). * SQLite connection got delColumn(). Now all connections fully support delColumn(). As SQLite backend doesn't implement "ALTER TABLE DROP COLUMN" delColumn() is implemented by creating a new table without the column, copying all data, dropping the original table and renaming the new table. * Versioning_. .. _Versioning: Versioning.html * MySQLConnection got new keyword "conv" - a list of custom converters. * Use logging if it's available and is configured via DB URI. * New columns: TimestampCol to support MySQL TIMESTAMP type; SetCol to support MySQL SET type; TinyIntCol for TINYINT; SmallIntCol for SMALLINT; MediumIntCol for MEDIUMINT; BigIntCol for BIGINT. Small Features -------------- * Support for MySQL INT type attributes: UNSIGNED, ZEROFILL. * Support for DEFAULT SQL attribute via defaultSQL keyword argument. * cls.tableExists() as a shortcut for conn.tableExists(cls.sqlmeta.table). * cls.deleteMany(), cls.deleteBy(). Bug Fixes --------- * idName can be inherited from the parent sqlmeta class. `Older news`__ .. __: News2.html .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/Versioning.rst0000644000175000017500000000517412753243417016475 0ustar phdphd00000000000000:Author: David Turner, The Open Planning Project .. contents:: Versioning ----------- Why ~~~ You have a table where rows can be altered, such as a table of wiki pages. You want to retain a history of changes for auditing, backup, or tracking purposes. You could write a decorator that stores old versions and manage all access to this object through it. Or you could take advantage of the event system in SQLObject 0.8+ and just catch row accesses to the object. SQLObject's versioning module does this for you. And it even works with inheritance! How ~~~ Here's how to set it up:: class MyClass(SQLObject): name = StringCol() versions = Versioning() To use it, just create an instance as usual:: mc = MyClass(name='fleem') Then make some changes and check out the results:: mc.set(name='morx') assert mc.versions[0].name == 'fleem' You can also restore to a previous version:: mc.versions[0].restore() assert mc.name == "fleem" Inheritance ~~~~~~~~~~~ There are three ways versioning can be used with inheritance_: .. _inheritance: Inheritance.html 1. Parent versioned, children unversioned:: class Base(InheritableSQLObject): name = StringCol() versions = Versioning() class Child(Base): toy = StringCol() In this case, when changes are made to an instance of Base, new versions are created. But when changes are made to an instance of Child, no new versions are created. 2. Children versioned, parents unversioned. In this case, when changes are made to an instance of Child, new versions are created. But when changes are made to an instance of Base, no new versions are created. The version data for Child contains all of the columns from child and from base, so that a full restore is possible. 3. Both children and parents versioned. In this case, changes to either Child or Base instances create new versions, but in different tables. Child versions still contain all Base data, and a change to a Child only creates a new Child version, not a new Base version. Version Tables ~~~~~~~~~~~~~~ Versions are stored in a special table which is created when the table for a versioned class is created. Version tables are not altered when the main table is altered, so if you add a column to your main class, you will need to manually add the column to your version table. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/SQLObject.rst0000644000175000017500000023474512753522777016161 0ustar phdphd00000000000000````````` SQLObject ````````` .. contents:: Contents: Credits ======= SQLObject is by Ian Bicking (ianb@colorstudy.com) and `Contributors `_. The website is `sqlobject.org `_. License ======= The code is licensed under the `Lesser General Public License`_ (LGPL). .. _`Lesser General Public License`: https://www.gnu.org/copyleft/lesser.html This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. Introduction ============ SQLObject is an *object-relational mapper* for Python_ programming language. It allows you to translate RDBMS table rows into Python objects, and manipulate those objects to transparently manipulate the database. .. _Python: https://www.python.org/ In using SQLObject, you will create a class definition that will describe how the object translates to the database table. SQLObject will produce the code to access the database, and update the database with your changes. The generated interface looks similar to any other interface, and callers need not be aware of the database backend. SQLObject also includes a novel feature to avoid generating, textually, your SQL queries. This also allows non-SQL databases to be used with the same query syntax. Requirements ============ Currently SQLObject supports MySQL_ via MySQLdb_ aka MySQL-python, PostgreSQL_ via psycopg2_ or psycopg1, SQLite_ via PySQLite_, Firebird_ via fdb_ or kinterbasdb_, `MAX DB`_ (also known as SAP DB) via sapdb_, Sybase via Sybase_, and `MSSQL Server`_ via pymssql_ (+ FreeTDS_) or adodbapi_ (Win32). .. _MySQL: https://www.mysql.com/ .. _MySQLdb: https://sourceforge.net/projects/mysql-python/ .. _PostgreSQL: https://postgresql.org .. _psycopg2: http://initd.org/psycopg/ .. _SQLite: https://sqlite.org/ .. _PySQLite: https://github.com/ghaering/pysqlite .. _Firebird: http://www.firebirdsql.org/en/python-driver/ .. _fdb: http://www.firebirdsql.org/en/devel-python-driver/ .. _kinterbasdb: http://kinterbasdb.sourceforge.net/ .. _`MAX DB`: http://maxdb.sap.com/ .. _sapdb: http://maxdb.sap.com/doc/7_8/50/01923f25b842438a408805774f6989/frameset.htm .. _Sybase: http://www.object-craft.com.au/projects/sybase/ .. _`MSSQL Server`: http://www.microsoft.com/sql/ .. _pymssql: http://www.pymssql.org/en/latest/index.html .. _FreeTDS: http://www.freetds.org/ .. _adodbapi: http://adodbapi.sourceforge.net/ Python 2.6, 2.7 or 3.4+ is required. Compared To Other Database Wrappers =================================== There are several object-relational mappers (ORM) for Python. I honestly can't comment deeply on the quality of those packages, but I'll try to place SQLObject in perspective. SQLObject uses new-style classes extensively. The resultant objects have a new-style feel as a result -- setting attributes has side effects (it changes the database), and defining classes has side effects (through the use of metaclasses). Attributes are generally exposed, not marked private, knowing that they can be made dynamic or write-only later. SQLObject creates objects that feel similar to normal Python objects (with the semantics of new-style classes). An attribute attached to a column doesn't look different than an attribute that's attached to a file, or an attribute that is calculated. It is a specific goal that you be able to change the database without changing the interface, including changing the scope of the database, making it more or less prominent as a storage mechanism. This is in contrast to some ORMs that provide a dictionary-like interface to the database (for example, PyDO_). The dictionary interface distinguishes the row from a normal Python object. I also don't care for the use of strings where an attribute seems more natural -- columns are limited in number and predefined, just like attributes. (Note: newer version of PyDO apparently allow attribute access as well) .. _PyDO: http://skunkweb.sourceforge.net/pydo.html SQLObject is, to my knowledge, unique in using metaclasses to facilitate this seamless integration. Some other ORMs use code generation to create an interface, expressing the schema in a CSV or XML file (for example, MiddleKit, part of Webware_). By using metaclasses you are able to comfortably define your schema in the Python source code. No code generation, no weird tools, no compilation step. .. _Webware: http://webware.sourceforge.net/ SQLObject provides a strong database abstraction, allowing cross-database compatibility (so long as you don't sidestep SQLObject). SQLObject has joins, one-to-many, and many-to-many, something which many ORMs do not have. The join system is also intended to be extensible. You can map between database names and Python attribute and class names; often these two won't match, or the database style would be inappropriate for a Python attribute. This way your database schema does not have to be designed with SQLObject in mind, and the resulting classes do not have to inherit the database's naming schemes. Using SQLObject: An Introduction ================================ Let's start off quickly. We'll generally just import everything from the ``sqlobject`` class:: >>> from sqlobject import * >>> import sys, os Declaring a Connection ---------------------- The connection URI must follow the standard URI syntax:: scheme://[user[:password]@]host[:port]/database[?parameters] Scheme is one of ``sqlite``, ``mysql``, ``postgres``, ``firebird``, ``interbase``, ``maxdb``, ``sapdb``, ``mssql``, ``sybase``. Examples:: mysql://user:password@host/database mysql://host/database?debug=1 postgres://user@host/database?debug=&cache= postgres:///full/path/to/socket/database postgres://host:5432/database sqlite:///full/path/to/database sqlite:/C:/full/path/to/database sqlite:/:memory: Parameters are: ``debug`` (default: False), ``debugOutput`` (default: False), ``cache`` (default: True), ``autoCommit`` (default: True), ``debugThreading`` (default: False), ``logger`` (default: None), ``loglevel`` (default: None), ``schema`` (default: None). If you want to pass True value in a connection URI - pass any non-empty string; an empty string for False. Lets first set up a connection:: >>> db_filename = os.path.abspath('data.db') >>> if os.path.exists(db_filename): ... os.unlink(db_filename) >>> connection_string = 'sqlite:' + db_filename >>> connection = connectionForURI(connection_string) >>> sqlhub.processConnection = connection The ``sqlhub.processConnection`` assignment means that all classes will, by default, use this connection we've just set up. Declaring the Class ------------------- We'll develop a simple addressbook-like database. We could create the tables ourselves, and just have SQLObject access those tables, but let's have SQLObject do that work. First, the class: >>> class Person(SQLObject): ... ... firstName = StringCol() ... middleInitial = StringCol(length=1, default=None) ... lastName = StringCol() Many basic table schemas won't be any more complicated than that. `firstName`, `middleInitial`, and `lastName` are all columns in the database. The general schema implied by this class definition is:: CREATE TABLE person ( id INT PRIMARY KEY AUTO_INCREMENT, first_name TEXT, middle_initial CHAR(1), last_name TEXT ); This is for SQLite or MySQL. The schema for other databases looks slightly different (especially the ``id`` column). You'll notice the names were changed from mixedCase to underscore_separated -- this is done by the `style object`_. There are a variety of ways to handle names that don't fit conventions (see `Irregular Naming`_). .. _`style object`: `Changing the Naming Style`_ Now we'll create the table in the database:: >>> Person.createTable() [] We can change the type of the various columns by using something other than `StringCol`, or using different arguments. More about this in `Column Types`_. You'll note that the ``id`` column is not given in the class definition, it is implied. For MySQL databases it should be defined as ``INT PRIMARY KEY AUTO_INCREMENT``, in Postgres ``SERIAL PRIMARY KEY``, and in SQLite as ``INTEGER PRIMARY KEY``. You can't use tables with SQLObject that don't have a single primary key, and you must treat that key as immutable (otherwise you'll confuse SQLObject terribly). You can `override the id name`_ in the database, but it is always called ``.id`` from Python. .. _`override the id name`: `Class sqlmeta`_ Using the Class --------------- Now that you have a class, how will you use it? We'll be considering the class defined above. To create a new object (and row), use class instantiation, like:: >>> Person(firstName="John", lastName="Doe") .. note:: In SQLObject NULL/None does *not* mean default. NULL is a funny thing; it mean very different things in different contexts and to different people. Sometimes it means "default", sometimes "not applicable", sometimes "unknown". If you want a default, NULL or otherwise, you always have to be explicit in your class definition. Also note that the SQLObject default isn't the same as the database's default (SQLObject never uses the database's default). If you had left out ``firstName`` or ``lastName`` you would have gotten an error, as no default was given for these columns (``middleInitial`` has a default, so it will be set to ``NULL``, the database equivalent of ``None``). You can use the class method `.get()` to fetch instances that already exist:: >>> Person.get(1) When you create an object, it is immediately inserted into the database. SQLObject uses the database as immediate storage, unlike some other systems where you explicitly save objects into a database. Here's a longer example of using the class:: >>> p = Person.get(1) >>> p >>> p.firstName 'John' >>> p.middleInitial = 'Q' >>> p.middleInitial 'Q' >>> p2 = Person.get(1) >>> p2 >>> p is p2 True Columns are accessed like attributes. (This uses the ``property`` feature of Python, so that retrieving and setting these attributes executes code). Also note that objects are unique -- there is generally only one ``Person`` instance of a particular id in memory at any one time. If you ask for a person by a particular ID more than once, you'll get back the same instance. This way you can be sure of a certain amount of consistency if you have multiple threads accessing the same data (though of course across processes there can be no sharing of an instance). This isn't true if you're using transactions_, which are necessarily isolated. To get an idea of what's happening behind the surface, I'll give the same actions with the SQL that is sent, along with some commentary:: >>> # This will make SQLObject print out the SQL it executes: >>> Person._connection.debug = True >>> p = Person(firstName='Bob', lastName='Hope') 1/QueryIns: INSERT INTO person (first_name, middle_initial, last_name) VALUES ('Bob', NULL, 'Hope') 1/QueryR : INSERT INTO person (first_name, middle_initial, last_name) VALUES ('Bob', NULL, 'Hope') 1/COMMIT : auto 1/QueryOne: SELECT first_name, middle_initial, last_name FROM person WHERE ((person.id) = (2)) 1/QueryR : SELECT first_name, middle_initial, last_name FROM person WHERE ((person.id) = (2)) 1/COMMIT : auto >>> p >>> p.middleInitial = 'Q' 1/Query : UPDATE person SET middle_initial = ('Q') WHERE id = (2) 1/QueryR : UPDATE person SET middle_initial = ('Q') WHERE id = (2) 1/COMMIT : auto >>> p2 = Person.get(1) >>> # Note: no database access, since we're just grabbing the same >>> # instance we already had. Hopefully you see that the SQL that gets sent is pretty clear and predictable. To view the SQL being sent, add ``?debug=t`` to your connection URI, or set the ``debug`` attribute on the connection, and all SQL will be printed to the console. This can be reassuring, and I would encourage you to try it. .. comment: >>> Person._connection.debug = False As a small optimization, instead of assigning each attribute individually, you can assign a number of them using the ``set`` method, like:: >>> p.set(firstName='Robert', lastName='Hope Jr.') This will send only one ``UPDATE`` statement. You can also use `set` with non-database properties (there's no benefit, but it helps hide the difference between database and non-database attributes). Selecting Multiple Objects -------------------------- While the full power of all the kinds of joins you can do with a relational database are not revealed in SQLObject, a simple ``SELECT`` is available. ``select`` is a class method, and you call it like (with the SQL that's generated):: >>> Person._connection.debug = True >>> peeps = Person.select(Person.q.firstName=="John") >>> list(peeps) 1/Select : SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE ((person.first_name) = ('John')) 1/QueryR : SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE ((person.first_name) = ('John')) 1/COMMIT : auto [] This example returns everyone with the first name John. Queries can be more complex:: >>> peeps = Person.select( ... OR(Person.q.firstName == "John", ... LIKE(Person.q.lastName, "%Hope%"))) >>> list(peeps) 1/Select : SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE (((person.first_name) = ('John')) OR (person.last_name LIKE ('%Hope%'))) 1/QueryR : SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE (((person.first_name) = ('John')) OR (person.last_name LIKE ('%Hope%'))) 1/COMMIT : auto [, ] You'll note that classes have an attribute ``q``, which gives access to special objects for constructing query clauses. All attributes under ``q`` refer to column names and if you construct logical statements with these it'll give you the SQL for that statement. You can also create your SQL more manually:: >>> Person._connection.debug = False # Need for doctests >>> peeps = Person.select("""person.first_name = 'John' AND ... person.last_name LIKE 'D%'""") You should use `MyClass.sqlrepr` to quote any values you use if you create SQL manually (quoting is automatic if you use ``q``). .. _orderBy: You can use the keyword arguments `orderBy` to create ``ORDER BY`` in the select statements: `orderBy` takes a string, which should be the *database* name of the column, or a column in the form ``Person.q.firstName``. You can use ``"-colname"`` or ``DESC(Person.q.firstName``) to specify descending order (this is translated to DESC, so it works on non-numeric types as well), or call ``MyClass.select().reversed()``. orderBy can also take a list of columns in the same format: ``["-weight", "name"]``. You can use the `sqlmeta`_ class variable `defaultOrder` to give a default ordering for all selects. To get an unordered result when `defaultOrder` is used, use ``orderBy=None``. .. _`sqlmeta`: `Class sqlmeta`_ Select results are generators, which are lazily evaluated. So the SQL is only executed when you iterate over the select results, or if you use ``list()`` to force the result to be executed. When you iterate over the select results, rows are fetched one at a time. This way you can iterate over large results without keeping the entire result set in memory. You can also do things like ``.reversed()`` without fetching and reversing the entire result -- instead, SQLObject can change the SQL that is sent so you get equivalent results. You can also slice select results. This modifies the SQL query, so ``peeps[:10]`` will result in ``LIMIT 10`` being added to the end of the SQL query. If the slice cannot be performed in the SQL (e.g., peeps[:-10]), then the select is executed, and the slice is performed on the list of results. This will generally only happen when you use negative indexes. In certain cases, you may get a select result with an object in it more than once, e.g., in some joins. If you don't want this, you can add the keyword argument ``MyClass.select(..., distinct=True)``, which results in a ``SELECT DISTINCT`` call. You can get the length of the result without fetching all the results by calling ``count`` on the result object, like ``MyClass.select().count()``. A ``COUNT(*)`` query is used -- the actual objects are not fetched from the database. Together with slicing, this makes batched queries easy to write: start = 20 size = 10 query = Table.select() results = query[start:start+size] total = query.count() print "Showing page %i of %i" % (start/size + 1, total/size + 1) .. note:: There are several factors when considering the efficiency of this kind of batching, and it depends very much how the batching is being used. Consider a web application where you are showing an average of 100 results, 10 at a time, and the results are ordered by the date they were added to the database. While slicing will keep the database from returning all the results (and so save some communication time), the database will still have to scan through the entire result set to sort the items (so it knows which the first ten are), and depending on your query may need to scan through the entire table (depending on your use of indexes). Indexes are probably the most important way to improve importance in a case like this, and you may find caching to be more effective than slicing. In this case, caching would mean retrieving the *complete* results. You can use ``list(MyClass.select(...))`` to do this. You can save these results for some limited period of time, as the user looks through the results page by page. This means the first page in a search result will be slightly more expensive, but all later pages will be very cheap. For more information on the where clause in the queries, see the `SQLBuilder documentation`_. q-magic ~~~~~~~ Please note the use of the `q` attribute in examples above. `q` is an object that returns special objects to construct SQL expressions. Operations on objects returned by `q-magic` are not evaluated immediately but stored in a manner similar to symbolic algebra; the entire expression is evaluated by constructing a string that is sent then to the backend. For example, for the code:: >>> peeps = Person.select(Person.q.firstName=="John") SQLObject doesn't evaluate firstName but stores the expression: Person.q.firstName=="John" converts it to the string ``first_name = 'John'`` and passes the string to the backend. selectBy Method ~~~~~~~~~~~~~~~ An alternative to ``.select`` is ``.selectBy``. It works like: >>> peeps = Person.selectBy(firstName="John", lastName="Doe") Each keyword argument is a column, and all the keyword arguments are ANDed together. The return value is a `SelectResult`, so you can slice it, count it, order it, etc. Lazy Updates ------------ By default SQLObject sends an ``UPDATE`` to the database for every attribute you set, or every time you call ``.set()``. If you want to avoid this many updates, add ``lazyUpdate = True`` to your class `sqlmeta definition`_. .. _`sqlmeta definition`: `Class sqlmeta`_ Then updates will only be written to the database when you call ``inst.syncUpdate()`` or ``inst.sync()``: ``.sync()`` also refetches the data from the database, which ``.syncUpdate()`` does not do. When enabled instances will have a property ``.sqlmeta.dirty``, which indicates if there are pending updates. Inserts are still done immediately; there's no way to do lazy inserts at this time. One-to-Many Relationships ------------------------- An address book is nothing without addresses. First, let's define the new address table. People can have multiple addresses, of course:: >>> class Address(SQLObject): ... ... street = StringCol() ... city = StringCol() ... state = StringCol(length=2) ... zip = StringCol(length=9) ... person = ForeignKey('Person') >>> Address.createTable() [] Note the column ``person = ForeignKey("Person")``. This is a reference to a `Person` object. We refer to other classes by name (with a string). In the database there will be a ``person_id`` column, type ``INT``, which points to the ``person`` column. .. note:: The reason SQLObject uses strings to refer to other classes is because the other class often does not yet exist. Classes in Python are *created*, not *declared*; so when a module is imported the commands are executed. ``class`` is just another command; one that creates a class and assigns it to the name you give. If class ``A`` referred to class ``B``, but class ``B`` was defined below ``A`` in the module, then when the ``A`` class was created (including creating all its column attributes) the ``B`` class simply wouldn't exist. By referring to classes by name, we can wait until all the required classes exist before creating the links between classes. We want an attribute that gives the addresses for a person. In a class definition we'd do:: class Person(SQLObject): ... addresses = MultipleJoin('Address') But we already have the class. We can add this to the class in-place:: >>> Person.sqlmeta.addJoin(MultipleJoin('Address', ... joinMethodName='addresses')) .. note:: In almost all cases you can modify SQLObject classes after they've been created. Having attributes that contain ``*Col`` objects in the class definition is equivalent to calling certain class methods (like ``addColumn()``). Now we can get the backreference with ``aPerson.addresses``, which returns a list. An example:: >>> p.addresses [] >>> Address(street='123 W Main St', city='Smallsville', ... state='MN', zip='55407', person=p)
>>> p.addresses [
] .. note:: MultipleJoin, as well as RelatedJoin, returns a list of results. It is often preferable to get a `SelectResults`_ object instead, in which case you should use SQLMultipleJoin and SQLRelatedJoin. The declaration of these joins is unchanged from above, but the returned iterator has many additional useful methods. .. _`SelectResults` : SelectResults.html Many-to-Many Relationships -------------------------- For this example we will have user and role objects. The two have a many-to-many relationship, which is represented with the `RelatedJoin`. >>> class User(SQLObject): ... ... class sqlmeta: ... # user is a reserved word in some databases, so we won't ... # use that for the table name: ... table = "user_table" ... ... username = StringCol(alternateID=True, length=20) ... # We'd probably define more attributes, but we'll leave ... # that exercise to the reader... ... ... roles = RelatedJoin('Role') >>> class Role(SQLObject): ... ... name = StringCol(alternateID=True, length=20) ... ... users = RelatedJoin('User') >>> User.createTable() [] >>> Role.createTable() [] .. note:: The sqlmeta class is used to store different kinds of metadata (and override that metadata, like table). This is new in SQLObject 0.7. See the section `Class sqlmeta`_ for more information on how it works and what attributes have special meanings. And usage:: >>> bob = User(username='bob') >>> tim = User(username='tim') >>> jay = User(username='jay') >>> admin = Role(name='admin') >>> editor = Role(name='editor') >>> bob.addRole(admin) >>> bob.addRole(editor) >>> tim.addRole(editor) >>> bob.roles [, ] >>> tim.roles [] >>> jay.roles [] >>> admin.users [] >>> editor.users [, ] In the process an intermediate table is created, ``role_user``, which references both of the other classes. This table is never exposed as a class, and its rows do not have equivalent Python objects -- this hides some of the nuisance of a many-to-many relationship. By the way, if you want to create an intermediate table of your own, maybe with additional columns, be aware that the standard SQLObject methods add/removesomething may not work as expected. Assuming that you are providing the join with the correct joinColumn and otherColumn arguments, be aware it's not possible to insert extra data via such methods, nor will they set any default value. Let's have an example: in the previous User/Role system, you're creating a UserRole intermediate table, with the two columns containing the foreign keys for the MTM relationship, and an additional DateTimeCol defaulting to datetime.datetime.now : that column will stay empty when adding roles with the addRole method. If you want to get a list of rows from the intermediate table directly add a MultipleJoin to User or Role class. You may notice that the columns have the extra keyword argument `alternateID`. If you use ``alternateID=True``, this means that the column uniquely identifies rows -- like a username uniquely identifies a user. This identifier is in addition to the primary key (``id``), which is always present. .. note:: SQLObject has a strong requirement that the primary key be unique and *immutable*. You cannot change the primary key through SQLObject, and if you change it through another mechanism you can cause inconsistency in any running SQLObject program (and in your data). For this reason meaningless integer IDs are encouraged -- something like a username that could change in the future may uniquely identify a row, but it may be changed in the future. So long as it is not used to reference the row, it is also *safe* to change it in the future. A alternateID column creates a class method, like ``byUsername`` for a column named ``username`` (or you can use the `alternateMethodName` keyword argument to override this). Its use: >>> User.byUsername('bob') >>> Role.byName('admin') Selecting Objects Using Relationships ------------------------------------- An select expression can refer to multiple classes, like:: >>> Person._connection.debug = False # Needed for doctests >>> peeps = Person.select( ... AND(Address.q.personID == Person.q.id, ... Address.q.zip.startswith('504'))) >>> list(peeps) [] >>> peeps = Person.select( ... AND(Address.q.personID == Person.q.id, ... Address.q.zip.startswith('554'))) >>> list(peeps) [] It is also possible to use the ``q`` attribute when constructing complex queries, like:: >>> Person._connection.debug = False # Needed for doctests >>> peeps = Person.select("""address.person_id = person.id AND ... address.zip LIKE '504%'""", ... clauseTables=['address']) Note that you have to use ``clauseTables`` if you use tables besides the one you are selecting from. If you use the ``q`` attributes SQLObject will automatically figure out what extra classes you might have used. Class sqlmeta ------------- This new class is available starting with SQLObject 0.7 and allows specifying metadata in a clearer way, without polluting the class namespace with more attributes. There are some special attributes that can be used inside this class that will change the behavior of the class that contains it. Those values are: `table`: The name of the table in the database. This is derived from ``style`` and the class name if no explicit name is given. If you don't give a name and haven't defined an alternative ``style``, then the standard `MixedCase` to `mixed_case` translation is performed. `idName`: The name of the primary key column in the database. This is derived from ``style`` if no explicit name is given. The default name is ``id``. `idType`: A function that coerces/normalizes IDs when setting IDs. This is ``int`` by default (all IDs are normalized to integers). `style`: A style object -- this object allows you to use other algorithms for translating between Python attribute and class names, and the database's column and table names. See `Changing the Naming Style`_ for more. It is an instance of the `IStyle` interface. `lazyUpdate`: A boolean (default false). If true, then setting attributes on instances (or using ``inst.set(.)`` will not send ``UPDATE`` queries immediately (you must call ``inst.syncUpdates()`` or ``inst.sync()`` first). `defaultOrder`: When selecting objects and not giving an explicit order, this attribute indicates the default ordering. It is like this value is passed to ``.select()`` and related methods; see those method's documentation for details. `cacheValues`: A boolean (default true). If true, then the values in the row are cached as long as the instance is kept (and ``inst.expire()`` is not called). If set to `False` then values for attributes from the database won't be cached. So every time you access an attribute in the object the database will be queried for a value, i.e., a ``SELECT`` will be issued. If you want to handle concurrent access to the database from multiple processes then this is probably the way to do so. `registry`: Because SQLObject uses strings to relate classes, and these strings do not respect module names, name clashes will occur if you put different systems together. This string value serves as a namespace for classes. `fromDatabase`: A boolean (default false). If true, then on class creation the database will be queried for the table's columns, and any missing columns (possible all columns) will be added automatically. `dbEncoding`: UnicodeCol_ looks up `sqlmeta.dbEncoding` if `column.dbEncoding` is ``None`` (if `sqlmeta.dbEncoding` is ``None`` UnicodeCol_ looks up `connection.dbEncoding` and if `dbEncoding` isn't defined anywhere it defaults to ``"utf-8"``). .. _UnicodeCol: `Column Types`_ The following attributes provide introspection but should not be set directly - see `Runtime Column and Join Changes`_ for dynamically modifying these class elements. `columns`: A dictionary of ``{columnName: anSOColInstance}``. You can get information on the columns via this read-only attribute. `columnList`: A list of the values in ``columns``. Sometimes a stable, ordered version of the columns is necessary; this is used for that. `columnDefinitions`: A dictionary like ``columns``, but contains the original column definitions (which are not class-specific, and have no logic). `joins`: A list of all the Join objects for this class. `indexes`: A list of all the indexes for this class. `createSQL`: SQL queries run after table creation. createSQL can be a string with a single SQL command, a list of SQL commands, or a dictionary with keys that are dbNames and values that are either single SQL command string or a list of SQL commands. This is usually for ALTER TABLE commands. There is also one instance attribute: `expired`: A boolean. If true, then the next time this object's column attributes are accessed a query will be run. While in previous versions of SQLObject those attributes were defined directly at the class that will map your database data to Python and all of them were prefixed with an underscore, now it is suggested that you change your code to this new style. The old way was removed in SQLObject 0.8. Please note: when using InheritedSQLObject, sqlmeta attributes don't get inherited, e.g. you can't access via the sqlmeta.columns dictionary the parent's class column objects. Using sqlmeta ~~~~~~~~~~~~~ To use sqlmeta you should write code like this example:: class MyClass(SQLObject): class sqlmeta: lazyUpdate = True cacheValues = False columnA = StringCol() columnB = IntCol() def _set_attr1(self, value): # do something with value def _get_attr1(self): # do something to retrieve value The above definition is creating a table ``my_class`` (the name may be different if you change the ``style`` used) with two columns called columnA and columnB. There's also a third field that can be accessed using ``MyClass.attr1``. The sqlmeta class is changing the behavior of ``MyClass`` so that it will perform lazy updates (you'll have to call the ``.sync()`` method to write the updates to the database) and it is also telling that ``MyClass`` won't have any cache, so that every time you ask for some information it will be retrieved from the database. j-magic ~~~~~~~ There is a magic attribute `j` similar to q_ with attributes for ForeignKey and SQLMultipleJoin/SQLRelatedJoin, providing a shorthand for the SQLBuilder join expressions to traverse the given relationship. For example, for a ForeignKey AClass.j.someB is equivalent to (AClass.q.someBID==BClass.q.id), as is BClass.j.someAs for the matching SQLMultipleJoin. .. _q: q-magic_ SQLObject Class --------------- There is one special attribute - `_connection`. It is the connection defined for the table. `_connection`: The connection object to use, from `DBConnection`. You can also set the variable `__connection__` in the enclosing module and it will be picked up (be sure to define `__connection__` before your class). You can also pass a connection object in at instance creation time, as described in transactions_. If you have defined `sqlhub.processConnection` then this attribute can be omitted from your class and the sqlhub will be used instead. If you have several classes using the same connection that might be an advantage, besides saving a lot of typing. Customizing the Objects ----------------------- While we haven't done so in the examples, you can include your own methods in the class definition. Writing your own methods should be obvious enough (just do so like in any other class), but there are some other details to be aware of. Initializing the Objects ~~~~~~~~~~~~~~~~~~~~~~~~ There are two ways SQLObject instances can come into existence: they can be fetched from the database, or they can be inserted into the database. In both cases a new Python object is created. This makes the role of `__init__` a little confusing. In general, you should not touch `__init__`. Instead use the `_init` method, which is called after an object is fetched or inserted. This method has the signature ``_init(self, id, connection=None, selectResults=None)``, though you may just want to use ``_init(self, *args, **kw)``. **Note:** don't forget to call ``SQLObject._init(self, *args, **kw)`` if you override the method! Adding Magic Attributes (properties) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can use all the normal techniques for defining methods in this new-style class, including `classmethod`, `staticmethod`, and `property`, but you can also use a shortcut. If you have a method that's name starts with ``_set_``, ``_get_``, ``_del_``, or ``_doc_``, it will be used to create a property. So, for instance, say you have images stored under the ID of the person in the ``/var/people/images`` directory:: class Person(SQLObject): # ... def imageFilename(self): return 'images/person-%s.jpg' % self.id def _get_image(self): if not os.path.exists(self.imageFilename()): return None f = open(self.imageFilename()) v = f.read() f.close() return v def _set_image(self, value): # assume we get a string for the image f = open(self.imageFilename(), 'w') f.write(value) f.close() def _del_image(self, value): # I usually wouldn't include a method like this, but for # instructional purposes... os.unlink(self.imageFilename()) Later, you can use the ``.image`` property just like an attribute, and the changes will be reflected in the filesystem by calling these methods. This is a good technique for information that is better to keep in files as opposed to the database (such as large, opaque data like images). You can also pass an ``image`` keyword argument to the constructor or the `set` method, like ``Person(..., image=imageText)``. All of the methods (``_get_``, ``_set_``, etc) are optional -- you can use any one of them without using the others. So you could define just a ``_get_attr`` method so that ``attr`` was read-only. Overriding Column Attributes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ It's a little more complicated if you want to override the behavior of an database column attribute. For instance, imagine there's special code you want to run whenever someone's name changes. In many systems you'd do some custom code, then call the superclass's code. But the superclass (``SQLObject``) doesn't know anything about the column in your subclass. It's even worse with properties. SQLObject creates methods like ``_set_lastName`` for each of your columns, but again you can't use this, since there's no superclass to reference (and you can't write ``SQLObject._set_lastName(...)``, because the SQLObject class doesn't know about your class's columns). You want to override that ``_set_lastName`` method yourself. To deal with this, SQLObject creates two methods for each getter and setter, for example: ``_set_lastName`` and ``_SO_set_lastName``. So to intercept all changes to ``lastName``:: class Person(SQLObject): lastName = StringCol() firstName = StringCol() def _set_lastName(self, value): self.notifyLastNameChange(value) self._SO_set_lastName(value) Or perhaps you want to constrain a phone numbers to be actual digits, and of proper length, and make the formatting nice:: import re class PhoneNumber(SQLObject): phoneNumber = StringCol(length=30) _garbageCharactersRE = re.compile(r'[\-\.\(\) ]') _phoneNumberRE = re.compile(r'^[0-9]+$') def _set_phoneNumber(self, value): value = self._garbageCharactersRE.sub('', value) if not len(value) >= 10: raise ValueError( 'Phone numbers must be at least 10 digits long') if not self._phoneNumberRE.match(value): raise ValueError, 'Phone numbers can contain only digits' self._SO_set_phoneNumber(value) def _get_phoneNumber(self): value = self._SO_get_phoneNumber() number = '(%s) %s-%s' % (value[0:3], value[3:6], value[6:10]) if len(value) > 10: number += ' ext.%s' % value[10:] return number .. note:: You should be a little cautious when modifying data that gets set in an attribute. Generally someone using your class will expect that the value they set the attribute to will be the same value they get back. In this example we removed some of the characters before putting it in the database, and reformatted it on the way out. One advantage of methods (as opposed to attribute access) is that the programmer is more likely to expect this disconnect. Also note while these conversions will take place when getting and setting the column, in queries the conversions will not take place. So if you convert the value from a "Pythonic" representation to a "SQLish" representation, your queries (when using ``.select()`` and ``.selectBy()``) will have to be in terms of the SQL/Database representation (as those commands generate SQL that is run on the database). Undefined attributes ~~~~~~~~~~~~~~~~~~~~ There's one more thing worth telling, because you may something get strange results when making a typo. SQLObject won't ever complain or raise any error when setting a previously undefined attribute; it will simply set it, without making any change to the database, i.e: it will work as any other attribute you set on any Python class, it will 'forget' it is a SQLObject class. This may sometimes be a problem: if you have got a 'name' attribute and you you write 'a.namme="Victor"' once, when setting it, you'll get no error, no warning, nothing at all, and you may get crazy at understanding why you don't get that value set in your DB. Reference ========= The instructions above should tell you enough to get you started, and be useful for many situations. Now we'll show how to specify the class more completely. Col Class: Specifying Columns ----------------------------- The list of columns is a list of `Col` objects. These objects don't have functionality in themselves, but give you a way to specify the column. `dbName`: This is the name of the column in the database. If you don't give a name, your Pythonic name will be converted from mixed-case to underscore-separated. `default`: The default value for this column. Used when creating a new row. If you give a callable object or function, the function will be called, and the return value will be used. So you can give ``DateTimeCol.now`` to make the default value be the current time. Or you can use ``sqlbuilder.func.NOW()`` to have the database use the ``NOW()`` function internally. If you don't give a default there will be an exception if this column isn't specified in the call to `new`. `defaultSQL`: ``DEFAULT`` SQL attribute. `alternateID`: This boolean (default False) indicates if the column can be used as an ID for the field (for instance, a username), though it is not a primary key. If so a class method will be added, like ``byUsername`` which will return that object. Use `alternateMethodName` if you don't like the ``by*`` name (e.g. ``alternateMethodName="username"``). The column should be declared ``UNIQUE`` in your table schema. `unique`: If true, when SQLObject creates a table it will declare this column to be ``UNIQUE``. `notNone`: If true, None/``NULL`` is not allowed for this column. Useful if you are using SQLObject to create your tables. `sqlType`: The SQL type for this column (like ``INT``, ``BOOLEAN``, etc). You can use classes (defined below) for this, but if those don't work it's sometimes easiest just to use `sqlType`. Only necessary if SQLObject is creating your tables. `validator`: formencode_-like validator_. Making long story short, this is an object that provides ``to_python()`` and ``from_python()`` to validate *and* convert (adapt or cast) the values when they are read/written from/to the database. You should see formencode_ validator_ documentation for more details. This validator is appended to the end of the list of the list of column validators. If the column has a list of validators their ``from_python()`` methods are ran from the beginnig of the list to the end; ``to_python()`` in the reverse order. That said, ``from_python()`` method of this validator is called last, after all validators in the list; ``to_python()`` is called first. `validator2`: Another validator. It is inserted in the beginning of the list of the list of validators, i.e. its ``from_python()`` method is called first; ``to_python()`` last. .. _formencode: http://formencode.org/ .. _validator: http://www.formencode.org/en/latest/Validator.html Column Types ~~~~~~~~~~~~ The `ForeignKey` class should be used instead of `Col` when the column is a reference to another table/class. It is generally used like ``ForeignKey('Role')``, in this instance to create a reference to a table `Role`. This is largely equivalent to ``Col(foreignKey='Role', sqlType='INT')``. Two attributes will generally be created, ``role``, which returns a `Role` instance, and ``roleID``, which returns an integer ID for the related role. There are some other subclasses of `Col`. These are used to indicate different types of columns, when SQLObject creates your tables. `BLOBCol`: A column for binary data. Presently works only with MySQL, PostgreSQL and SQLite backends. `BoolCol`: Will create a ``BOOLEAN`` column in Postgres, or ``INT`` in other databases. It will also convert values to ``"t"/"f"`` or ``0/1`` according to the database backend. `CurrencyCol`: Equivalent to ``DecimalCol(size=10, precision=2)``. WARNING: as DecimalCol MAY NOT return precise numbers, this column may share the same behavior. Please read the DecimalCol warning. `DateTimeCol`: A date and time (usually returned as an datetime or mxDateTime object). `DateCol`: A date (usually returned as an datetime or mxDateTime object). `TimeCol`: A time (usually returned as an datetime or mxDateTime object). `TimestampCol`: Supports MySQL TIMESTAMP type. `DecimalCol`: Base-10, precise number. Uses the keyword arguments `size` for number of digits stored, and `precision` for the number of digits after the decimal point. WARNING: it may happen that DecimalCol values, although correctly stored in the DB, are returned as floats instead of decimals. For example, due to the `type affinity`_ SQLite stores decimals as integers or floats (NUMERIC storage class). You should test with your database adapter, and you should try importing the Decimal type and your DB adapter before importing SQLObject. .. _`type affinity`: http://sqlite.org/datatype3.html#affinity `DecimalStringCol`: Similar to `DecimalCol` but stores data as strings to work around problems in some drivers and type affinity problem in SQLite. As it stores data as strings the column cannot be used in SQL expressions (column1 + column2) and probably will has problems with ORDER BY. `EnumCol`: One of several string values -- give the possible strings as a list, with the `enumValues` keyword argument. MySQL has a native ``ENUM`` type, but will work with other databases too (storage just won't be as efficient). For PostgreSQL, EnumCol's are implemented using check constraints. Due to the way PostgreSQL handles check constraints involving NULL, specifying None as a member of an EnumCol will effectively mean that, at the SQL level, the check constraint will be ignored (see http://archives.postgresql.org/pgsql-sql/2004-12/msg00065.php for more details). `SetCol`: Supports MySQL SET type. `FloatCol`: Floats. `ForeignKey`: A key to another table/class. Use like ``user = ForeignKey('User')``. It can check for referential integrity using the keyword argument `cascade`, please see ForeignKey_ for details. `IntCol`: Integers. `JsonbCol`: A column for jsonb objects. Only supported on Postgres. Any Python object that can be serialized with json.dumps can be stored. `JSONCol`: A universal json column that converts simple Python objects (None, bool, int, float, long, dict, list, str/unicode to/from JSON using json.dumps/loads. A subclass of StringCol. `PickleCol`: An extension of BLOBCol; this column can store/retrieve any Python object; it actually (un)pickles the object from/to string and stores/retrieves the string. One can get and set the value of the column but cannot search (use it in WHERE). `StringCol`: A string (character) column. Extra keywords: `length`: If given, the type will be something like ``VARCHAR(length)``. If not given, then ``TEXT`` is assumed (i.e., lengthless). `varchar`: A boolean; if you have a length, differentiates between ``CHAR`` and ``VARCHAR``, default True, i.e., use ``VARCHAR``. `UnicodeCol`: A subclass of `StringCol`. Also accepts a `dbEncoding` keyword argument, it defaults to ``None`` which means to lookup `dbEncoding` in sqlmeta_ and connection, and if `dbEncoding` isn't defined anywhere it defaults to ``"utf-8"``. Values coming in and out from the database will be encoded and decoded. **Note**: there are some limitations on using UnicodeCol in queries: - only simple q-magic fields are supported; no expressions; - only == and != operators are supported; The following code works:: MyTable.select(u'value' == MyTable.q.name) MyTable.select(MyTable.q.name != u'value') MyTable.select(OR(MyTable.q.col1 == u'value1', MyTable.q.col2 != u'value2')) MyTable.selectBy(name = u'value') MyTable.selectBy(col1=u'value1', col2=u'value2') MyTable.byCol1(u'value1') # if col1 is an alternateID The following does not work:: MyTable.select((MyTable.q.name + MyTable.q.surname) == u'value') In that case you must apply the encoding yourself:: MyTable.select((MyTable.q.name + MyTable.q.surname) == u'value'.encode(dbEncoding)) `UuidCol`: A column for UUID. On Postgres uses 'UUID' data type, on all other backends uses VARCHAR(36). Relationships Between Classes/Tables ------------------------------------ ForeignKey ~~~~~~~~~~ You can use the `ForeignKey` to handle foreign references in a table, but for back references and many-to-many relationships you'll use joins. `ForeignKey` allows you to specify referential integrity using the keyword `cascade`, which can have these values: `None`: No action is taken on related deleted columns (this is the default). Following the Person/Address example, if you delete the object `Person` with id 1 (John Doe), the `Address` with id 1 (123 W Main St) will be kept untouched (with ``personID=1``). `False`: Deletion of an object that has other objects related to it using a `ForeignKey` will fail (sets ``ON DELETE RESTRICT``). Following the Person/Address example, if you delete the object `Person` with id 1 (John Doe) a `SQLObjectIntegrityError` exception will be raised, because the `Address` with id 1 (123 W Main St) has a reference (``personID=1``) to it. `True`: Deletion of an object that has other objects related to it using a `ForeignKey` will delete all the related objects too (sets ``ON DELETE CASCADE``). Following the Person/Address example, if you delete the object `Person` with id 1 (John Doe), the `Address` with id 1 (123 W Main St) will be deleted too. `'null'`: Deletion of an object that has other objects related to it using a `ForeignKey` will set the `ForeignKey` column to `NULL`/`None` (sets ``ON DELETE SET NULL``). Following the Person/Address example, if you delete the object `Person` with id 1 (John Doe), the `Address` with id 1 (123 W Main St) will be kept but the reference to person will be set to `NULL`/`None` (``personID=None``). MultipleJoin and SQLMultipleJoin: One-to-Many ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ See `One-to-Many Relationships`_ for an example of one-to-many relationships. MultipleJoin returns a list of results, while SQLMultipleJoin returns a SelectResults object. Several keyword arguments are allowed to the `MultipleJoin` constructor: .. _`Multiple Join Keywords`: `joinColumn`: The column name of the key that points to this table. So, if you have a table ``Product``, and another table has a column ``ProductNo`` that points to this table, then you'd use ``joinColumn="ProductNo"``. WARNING: the argument you pass must conform to the column name in the database, not to the column in the class. So, if you have a SQLObject containing the ``ProductNo`` column, this will probably be translated into ``product_no_id`` in the DB (``product_no`` is the normal uppercase- to-lowercase + underscores SQLO Translation, the added _id is just because the column referring to the table is probably a ForeignKey, and SQLO translates foreign keys that way). You should pass that parameter. `orderBy`: Like the `orderBy`_ argument to `select()`, you can specify the order that the joined objects should be returned in. `defaultOrder` will be used if not specified; ``None`` forces unordered results. `joinMethodName`: When adding joins dynamically (using the class method `addJoin`_), you can give the name of the accessor for the join. It can also be created automatically, and is normally implied (i.e., ``addresses = MultipleJoin(...)`` implies ``joinMethodName="addresses"``). RelatedJoin and SQLRelatedJoin: Many-to-Many ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ See `Many-to-Many Relationships`_ for examples of using many-to-many joins. RelatedJoin returns a list of results, while SQLRelatedJoin returns a SelectResults object. `RelatedJoin` has all the keyword arguments of `MultipleJoin`__, plus: __ `Multiple Join Keywords`_ `otherColumn`: Similar to `joinColumn`, but referring to the joined class. Same warning about column name. `intermediateTable`: The name of the intermediate table which references both classes. WARNING: you should pass the database table name, not the SQLO class representing. `addRemoveName`: In the `user/role example`__, the methods `addRole(role)` and `removeRole(role)` are created. The ``Role`` portion of these method names can be changed by giving a string value here. `createRelatedTable`: default: ``True``. If ``False``, then the related table won't be automatically created; instead you must manually create it (e.g., with explicit SQLObject classes for the joins). New in 0.7.1. .. note:: Let's suppose you have SQLObject-inherited classes Alpha and Beta, and an AlphasAndBetas used for the many-to-many relationship. AlphasAndBetas contains the alphaIndex Foreign Key column referring to Alpha, and the betaIndex FK column referring to Beta. if you want a 'betas' RelatedJoin in Alpha, you should add it to Alpha passing 'Beta' (class name!) as the first parameter, then passing 'alpha_index_id' as joinColumn, 'beta_index_id' as otherColumn, and 'alphas_and_betas' as intermediateTable. __ `Many-to-Many Relationships`_ An example schema that requires the use of `joinColumn`, `otherColumn`, and `intermediateTable`:: CREATE TABLE person ( id SERIAL, username VARCHAR(100) NOT NULL UNIQUE ); CREATE TABLE role ( id SERIAL, name VARCHAR(50) NOT NULL UNIQUE ); CREATE TABLE assigned_roles ( person INT NOT NULL, role INT NOT NULL ); Then the usage in a class:: class Person(SQLObject): username = StringCol(length=100, alternateID=True) roles = RelatedJoin('Role', joinColumn='person', otherColumn='role', intermediateTable='assigned_roles') class Role(SQLObject): name = StringCol(length=50, alternateID=True) roles = RelatedJoin('Person', joinColumn='role', otherColumn='person', intermediateTable='assigned_roles') SingleJoin: One-to-One ~~~~~~~~~~~~~~~~~~~~~~~~~ Similar to `MultipleJoin`, but returns just one object, not a list. Connection pooling ------------------ Connection object acquires a new low-level DB API connection from the pool and stores it; the low-level connection is removed from the pool; "releasing" means "return it to the pool". For single-threaded programs there is one connection in the pool. If the pool is empty a new low-level connection opened; if one has disabled pooling (by setting conn._pool = None) the connection will be closed instead of returning to the pool. Transactions ------------ Transaction support in SQLObject is left to the database. Transactions can be used like:: conn = DBConnection.PostgresConnection('yada') trans = conn.transaction() p = Person.get(1, trans) p.firstName = 'Bob' trans.commit() p.firstName = 'Billy' trans.rollback() The ``trans`` object here is essentially a wrapper around a single database connection, and `commit` and `rollback` just pass that message to the low-level connection. One can call as much ``.commit()``'s, but after a ``.rollback()`` one has to call ``.begin()``. The last ``.commit()`` should be called as ``.commit(close=True)`` to release low-level connection back to the connection pool. You can use SELECT FOR UPDATE in those databases that support it:: Person.select(Person.q.name=="value", forUpdate=True, connection=trans) Method ``sqlhub.doInTransaction`` can be used to run a piece of code in a transaction. The method accepts a callable and positional and keywords arguments. It begins a transaction using its ``processConnection`` or ``threadConnection``, calls the callable, commits the transaction and closes the underlying connection; it returns whatever the callable returned. If an error occurs during call to the callable it rolls the transaction back and reraise the exception. Automatic Schema Generation --------------------------- All the connections support creating and dropping tables based on the class definition. First you have to prepare your class definition, which means including type information in your columns. Indexes ~~~~~~~ You can also define indexes for your tables, which is only meaningful when creating your tables through SQLObject (SQLObject relies on the database to implement the indexes). You do this again with attribute assignment, like:: firstLastIndex = DatabaseIndex('firstName', 'lastName') This creates an index on two columns, useful if you are selecting a particular name. Of course, you can give a single column, and you can give the column object (``firstName``) instead of the string name. Note that if you use ``unique`` or ``alternateID`` (which implies ``unique``) the database may make an index for you, and primary keys are always indexed. If you give the keyword argument ``unique`` to `DatabaseIndex` you'll create a unique index -- the combination of columns must be unique. You can also use dictionaries in place of the column names, to add extra options. E.g.:: lastNameIndex = DatabaseIndex({'expression': 'lower(last_name)'}) In that case, the index will be on the lower-case version of the column. It seems that only PostgreSQL supports this. You can also do:: lastNameIndex = DatabaseIndex({'column': lastName, 'length': 10}) Which asks the database to only pay attention to the first ten characters. Only MySQL supports this, but it is ignored in other databases. Creating and Dropping Tables ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To create a table call `createTable`. It takes two arguments: `ifNotExists`: If the table already exists, then don't try to create it. Default False. `createJoinTables`: If you used `Many-to-Many relationships`_, then the intermediate tables will be created (but only for one of the two involved classes). Default True. `dropTable` takes arguments `ifExists` and `dropJoinTables`, self-explanatory. Dynamic Classes =============== SQLObject classes can be manipulated dynamically. This leaves open the possibility of constructing SQLObject classes from an XML file, from database introspection, or from a graphical interface. Automatic Class Generation --------------------------- SQLObject can read the table description from the database, and fill in the class columns (as would normally be described in the `_columns` attribute). Do this like:: class Person(SQLObject): class sqlmeta: fromDatabase = True You can still specify columns (in `_columns`), and only missing columns will be added. Runtime Column and Join Changes ------------------------------- You can add and remove columns to your class at runtime. Such changes will effect all instances, since changes are made in place to the class. There are two methods of the `class sqlmeta object`_, `addColumn` and `delColumn`, both of which take a `Col` object (or subclass) as an argument. There's also an option argument `changeSchema` which, if True, will add or drop the column from the database (typically with an ``ALTER`` command). When adding columns, you must pass the name as part of the column constructor, like ``StringCol("username", length=20)``. When removing columns, you can either use the Col object (as found in `sqlmeta.columns`, or which you used in `addColumn`), or you can use the column name (like ``MyClass.delColumn("username")``). .. _`class sqlmeta object`: `Class sqlmeta`_ .. _addJoin: You can also add Joins_, like ``MyClass.addJoin(MultipleJoin("MyOtherClass"))``, and remove joins with `delJoin`. `delJoin` does not take strings, you have to get the join object out of the `sqlmeta.joins` attribute. .. _Joins : `Relationships between Classes/Tables`_ Legacy Database Schemas ======================= Often you will have a database that already exists, and does not use the naming conventions that SQLObject expects, or does not use any naming convention at all. SQLObject requirements ---------------------- While SQLObject tries not to make too many requirements on your schema, some assumptions are made. Some of these may be relaxed in the future. All tables that you want to turn into a class need to have an integer primary key. That key should be defined like: MySQL: ``INT PRIMARY KEY AUTO_INCREMENT`` Postgres: ``SERIAL PRIMARY KEY`` SQLite: ``INTEGER PRIMARY KEY`` SQLObject does not support primary keys made up of multiple columns (that probably won't change). It does not generally support tables with primary keys with business meaning -- i.e., primary keys are assumed to be immutable (that won't change). At the moment foreign key column names must end in ``"ID"`` (case-insensitive). This restriction will probably be removed in the next release. Workaround for primary keys made up of multiple columns ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ If the database table/view has ONE NUMERIC Primary Key then sqlmeta - idName should be used to map the table column name to SQLObject id column. If the Primary Key consists only of number columns it is possible to create a virtual column ``id`` this way: Example for Postgresql: select '1'||lpad(PK1,max_length_of_PK1,'0')||lpad(PK2,max_length_of_PK2,'0')||...||lpad(PKn,max_length_of_PKn,'0') as "id", column_PK1, column_PK2, .., column_PKn, column... from table; Note: * The arbitrary '1' at the beginning of the string to allow for leading zeros of the first PK. * The application designer has to determine the maximum length of each Primary Key. This statement can be saved as a view or the column can be added to the database table, where it can be kept up to date with a database trigger. Obviously the "view" method does generally not allow insert, updates or deletes. For Postgresql you may want to consult the chapter "RULES" for manipulating underlying tables. For an alphanumeric Primary Key column a similar method is possible: Every character of the lpaded PK has to be transfered using ascii(character) which returns a 3digit number which can be concatenated as shown above. Caveats: * this way the ``id`` may become a very large integer number which may cause troubles elsewhere. * no performance loss takes place if the where clauses specifies the PK columns. Example: CD-Album * Album: PK=ean * Tracks: PK=ean,disc_nr,track_nr The database view to show the tracks starts: SELECT ean||lpad("disc_nr",2,'0')||lpad("track_nr",2,'0') as id, ... Note: no leading '1' and no padding necessary for ean numbers Tracks.select(Tracks.q.ean==id) ... where id is the ean of the Album. Changing the Naming Style ------------------------- By default names in SQLObject are expected to be mixed case in Python (like ``mixedCase``), and underscore-separated in SQL (like ``mixed_case``). This applies to table and column names. The primary key is assumed to be simply ``id``. Other styles exist. A typical one is mixed case column names, and a primary key that includes the table name, like ``ProductID``. You can use a different `Style` object to indicate a different naming convention. For instance:: class Person(SQLObject): class sqlmeta: style = MixedCaseStyle(longID=True) firstName = StringCol() lastName = StringCol() If you use ``Person.createTable()``, you'll get:: CREATE TABLE Person ( PersonID INT PRIMARY KEY, FirstName Text, LastName Text ) The `MixedCaseStyle` object handles the initial capitalization of words, but otherwise leaves them be. By using ``longID=True``, we indicate that the primary key should look like a normal reference (``PersonID`` for `MixedCaseStyle`, or ``person_id`` for the default style). If you wish to change the style globally, assign the style to the connection, like:: __connection__.style = MixedCaseStyle(longID=True) Irregular Naming ---------------- This is now covered in the `Class sqlmeta`_ section. Non-Integer Keys ---------------- While not strictly a legacy database issue, this fits into the category of "irregularities". If you use non-integer keys, all primary key management is up to you. You must create the table yourself (SQLObject can create tables with int or str IDs), and when you create instances you must pass a ``id`` keyword argument into constructor (like ``Person(id='555-55-5555', ...)``). DBConnection: Database Connections ================================== The `DBConnection` module currently has six external classes, `MySQLConnection`, `PostgresConnection`, `SQLiteConnection`, `SybaseConnection`, `MaxdbConnection`, `MSSQLConnection`. You can pass the keyword argument `debug` to any connector. If set to true, then any SQL sent to the database will also be printed to the console. You can additionally pass `logger` keyword argument which should be a name of the logger to use. If specified and `debug` is ``True``, SQLObject will write debug print statements via that logger instead of printing directly to console. The argument `loglevel` allows to choose the logging level - it can be ``debug``, ``info``, ``warning``, ``error``, ``critical`` or ``exception``. In case `logger` is absent or empty SQLObject uses ``print``'s instead of logging; `loglevel` can be ``stdout`` or ``stderr`` in this case; default is ``stdout``. To configure logging one can do something like that:: import logging logging.basicConfig() for handler in logging.root.handlers[:]: logging.root.removeHandler(handler) handler = logging.FileHandler("test.log") fmt = '[%(asctime)s] %(name)s %(levelname)s: %(message)s' handler.setFormatter(logging.Formatter(fmt)) logging.root.addHandler(handler) logging.root.setLevel(logging.DEBUG) log = logging.getLogger("TEST") log.info("Log started") __connection__ = "sqlite:/:memory:?debug=1&logger=TEST&loglevel=debug" The code redirects SQLObject debug messages to the `test.log` file. MySQL ----- `MySQLConnection` takes the keyword arguments `host`, `port`, `db`, `user`, and `password`, just like `MySQLdb.connect` does. MySQLConnection supports all the features, though MySQL only supports transactions_ when using the InnoDB backend, and SQLObject currently does not have support for explicitly defining the backend when using ``createTable``. Keyword argument ``conv`` allows to pass a list of custom converters. Example:: import time import sqlobject import MySQLdb.converters def _mysql_timestamp_converter(raw): """Convert a MySQL TIMESTAMP to a floating point number representing the seconds since the Un*x Epoch. It uses custom code the input seems to be the new (MySQL 4.1+) timestamp format, otherwise code from the MySQLdb module is used.""" if raw[4] == '-': return time.mktime(time.strptime(raw, '%Y-%m-%d %H:%M:%S')) else: return MySQLdb.converters.mysql_timestamp_converter(raw) conversions = MySQLdb.converters.conversions.copy() conversions[MySQLdb.constants.FIELD_TYPE.TIMESTAMP] = _mysql_timestamp_converter MySQLConnection = sqlobject.mysql.builder() connection = MySQLConnection(user='foo', db='somedb', conv=conversions) Postgres -------- `PostgresConnection` takes a single connection string, like ``"dbname=something user=some_user"``, just like `psycopg.connect`. You can also use the same keyword arguments as for `MySQLConnection`, and a dsn string will be constructed. PostgresConnection supports transactions and all other features. The user can choose a DB API driver for PostgreSQL by using a ``driver`` parameter in DB URI or PostgresConnection that can be a comma-separated list of driver names. Possible drivers are: ``psycopg2``, psycopg1, ``psycopg`` (tries psycopg2 and psycopg1), ``pygresql``. Default is ``psycopg``. SQLite ------ `SQLiteConnection` takes the a single string, which is the path to the database file. SQLite puts all data into one file, with a journal file that is opened in the same directory during operation (the file is deleted when the program quits). SQLite does not restrict the types you can put in a column -- strings can go in integer columns, dates in integers, etc. SQLite may have concurrency issues, depending on your usage in a multi-threaded environment. The user can choose a DB API driver for SQLite by using a ``driver`` parameter in DB URI or SQLiteConnection that can be a comma-separated list of driver names. Possible drivers are: ``pysqlite2`` (alias ``sqlite2``), ``sqlite3``, ``sqlite`` (alias ``sqlite1``). Default is to test pysqlite2, sqlite3 and sqlite in that order. Firebird -------- `FirebirdConnection` takes the arguments `host`, `db`, `user` (default ``"sysdba"``), `password` (default ``"masterkey"``). Firebird supports all the features. Support is still young, so there may be some issues, especially with concurrent access, and especially using lazy selects. Try ``list(MyClass.select())`` to avoid concurrent cursors if you have problems (using ``list()`` will pre-fetch all the results of a select). Firebird support uses fdb_ or kinterbasdb_ Python library. There could be a problem if one tries to connect to a server running on w32 from a program running on Unix; the problem is how to specify the database so that SQLObject correctly parses it. Vertical bar is replaces by a semicolon only on a w32. On Unix a vertical bar is a pretty normal character and must not be processed. The most correct way to fix the problem is to connect to the DB using a database name, not a file name. In the Firebird a DBA can set an alias instead of database name in the aliases.conf file Example from `Firebird 2.0 Administrators Manual`_:: # fbdb1 is on a Windows server: fbdb1 = c:\Firebird\sample\Employee.fdb .. _`Firebird 2.0 Administrators Manual`: http://www.firebirdmanual.com/firebird/en/firebird-manual/2 Now a program can connect to firebird://host:port/fbdb1. One can edit aliases.conf whilst the server is running. There is no need to stop and restart the server in order for new aliases.conf entries to be recognised. If you are using indexes and get an error like *key size exceeds implementation restriction for index*, see `this page`_ to understand the restrictions on your indexing. .. _this page: http://www.volny.cz/iprenosil/interbase/ip_ib_indexcalculator.htm Sybase ------ `SybaseConnection` takes the arguments `host`, `db`, `user`, and `password`. It also takes the extra boolean argument `locking` (default True), which is passed through when performing a connection. You may use a False value for `locking` if you are not using multiple threads, for a slight performance boost. It uses the Sybase_ module. MAX DB ------ MAX DB, also known as SAP DB, is available from a partnership of SAP and MySQL. It takes the typical arguments: `host`, `database`, `user`, `password`. It also takes the arguments `sqlmode` (default ``"internal"``), `isolation`, and `timeout`, which are passed through when creating the connection to the database. It uses the sapdb_ module. MS SQL Server ------------- The `MSSQLConnection` objects wants to use new style connection strings in the format of mssql://user:pass@host:port/db This will then be mapped to either the correct driver format. If running SQL Server on a "named" port, make sure to specify the port number in the URI. The two drivers currently supported are adodbapi_ and pymssql_. The user can choose a DB API driver for MSSQL by using a ``driver`` parameter in DB URI or MSSQLConnection that can be a comma-separated list of driver names. Possible drivers are: ``adodb`` (alias ``adodbapi``) and ``pymssql``. Default is to test ``adodbapi`` and ``pymssql`` in that order. Events (signals) ================ Signals are a mechanism to be notified when data or schema changes happen through SQLObject. This may be useful for doing custom data validation, logging changes, setting default attributes, etc. Some of what signals can do is also possible by overriding methods, but signals may provide a cleaner way, especially across classes not related by inheritance. Example:: from sqlobject.events import listen, RowUpdateSignal, RowCreatedSignal from model import Users def update_listener(instance, kwargs): """keep "last_updated" field current""" import datetime # BAD method 1, causes infinite recursion? # instance should be read-only instance.last_updated = datetime.datetime.now() # GOOD method 2 kwargs['last_updated'] = datetime.datetime.now() def created_listener(instance, kwargs, post_funcs): """"email me when new users added""" # email() implementation left as an exercise for the reader msg = "%s just was just added to the database!" % kwargs['name'] email(msg) listen(update_listener, Users, RowUpdateSignal) listen(created_listener, Users, RowCreatedSignal) Exported Symbols ================ You can use ``from sqlobject import *``, though you don't have to. It exports a minimal number of symbols. The symbols exported: From `sqlobject.main`: * `NoDefault` * `SQLObject` * `getID` * `getObject` From `sqlobject.col`: * `Col` * `StringCol` * `IntCol` * `FloatCol` * `KeyCol` * `ForeignKey` * `EnumCol` * `SetCol` * `DateTimeCol` * `DateCol` * `TimeCol` * `TimestampCol` * `DecimalCol` * `CurrencyCol` From `sqlobject.joins`: * `MultipleJoin` * `RelatedJoin` From `sqlobject.styles`: * `Style` * `MixedCaseUnderscoreStyle` * `DefaultStyle` * `MixedCaseStyle` From `sqlobject.sqlbuilder`: * `AND` * `OR` * `NOT` * `IN` * `LIKE` * `DESC` * `CONTAINSSTRING` * `const` * `func` LEFT JOIN and other JOINs ------------------------- First look in the FAQ_, question "How can I do a LEFT JOIN?" Still here? Well. To perform a JOIN use one of the JOIN helpers from SQLBuilder_. Pass an instance of the helper to .select() method. For example:: from sqlobject.sqlbuilder import LEFTJOINOn MyTable.select( join=LEFTJOINOn(Table1, Table2, Table1.q.name == Table2.q.value)) will generate the query:: SELECT my_table.* FROM my_table, table1 LEFT JOIN table2 ON table1.name = table2.value; .. _FAQ: FAQ.html#how-can-i-do-a-left-join If you want to join with the primary table - leave the first table None:: MyTable.select( join=LEFTJOINOn(None, Table1, MyTable.q.name == Table1.q.value)) will generate the query:: SELECT my_table.* FROM my_table LEFT JOIN table2 ON my_table.name = table1.value; The join argument for .select() can be a JOIN() or a sequence (list/tuple) of JOIN()s. Available joins are JOIN, INNERJOIN, CROSSJOIN, STRAIGHTJOIN, LEFTJOIN, LEFTOUTERJOIN, NATURALJOIN, NATURALLEFTJOIN, NATURALLEFTOUTERJOIN, RIGHTJOIN, RIGHTOUTERJOIN, NATURALRIGHTJOIN, NATURALRIGHTOUTERJOIN, FULLJOIN, FULLOUTERJOIN, NATURALFULLJOIN, NATURALFULLOUTERJOIN, INNERJOINOn, LEFTJOINOn, LEFTOUTERJOINOn, RIGHTJOINOn, RIGHTOUTERJOINOn, FULLJOINOn, FULLOUTERJOINOn, INNERJOINUsing, LEFTJOINUsing, LEFTOUTERJOINUsing, RIGHTJOINUsing, RIGHTOUTERJOINUsing, FULLJOINUsing, FULLOUTERJOINUsing. How can I join a table with itself? ----------------------------------- Use Alias from SQLBuilder_. Example:: from sqlobject.sqlbuilder import Alias alias = Alias(MyTable, "my_table_alias") MyTable.select(MyTable.q.name == alias.q.value) will generate the query:: SELECT my_table.* FROM my_table, my_table AS my_table_alias WHERE my_table.name = my_table_alias.value; Can I use a JOIN() with aliases? ---------------------------------- Sure! That's a situation the JOINs and aliases were primary developed for. Code:: from sqlobject.sqlbuilder import LEFTJOINOn, Alias alias = Alias(OtherTable, "other_table_alias") MyTable.select(MyTable.q.name == OtherTable.q.value, join=LEFTJOINOn(MyTable, alias, MyTable.col1 == alias.q.col2)) will result in the query:: SELECT my_table.* FROM other_table, my_table LEFT JOIN other_table AS other_table_alias WHERE my_table.name == other_table.value AND my_table.col1 = other_table_alias.col2. Subqueries (subselects) ----------------------- You can run queries with subqueries (subselects) on those DBMS that can do subqueries (MySQL supports subqueries from version 4.1). Use corresponding classes and functions from SQLBuilder_:: from sqlobject.sqlbuilder import EXISTS, Select select = Test1.select(EXISTS(Select(Test2.q.col2, where=(Outer(Test1).q.col1 == Test2.q.col2)))) generates the query:: SELECT test1.id, test1.col1 FROM test1 WHERE EXISTS (SELECT test2.col2 FROM test2 WHERE (test1.col1 = test2.col2)) Note the usage of Outer - it is a helper to allow referring to a table in the outer query. Select() is used instead of .select() because you need to control what columns the inner query returns. Available queries are ``IN()``, ``NOTIN()``, ``EXISTS()``, ``NOTEXISTS()``, ``SOME()``, ``ANY()`` and ``ALL()``. The last 3 are used with comparison operators, like this: ``somevalue = ANY(Select(...))``. Utilities --------- Some useful utility functions are included with SQLObject. For more information see their module docstrings. * `sqlobject.util.csvexport `_ SQLBuilder ---------- For more information on SQLBuilder, read the `SQLBuilder Documentation`_. .. _SQLBuilder: SQLBuilder.html .. _`SQLBuilder Documentation`: SQLBuilder.html .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/Views.rst0000644000175000017500000000453012752476767015461 0ustar phdphd00000000000000Views and SQLObjects ==================== In general, if your database backend supports defining views you may define them outside of SQLObject and treat them as a regular table when defining your SQLObject class. ViewSQLObject ------------- The rest of this document is experimental. ``from sqlobject.views import *`` ``ViewSQLObject`` is an attempt to allow defining views that allow you to define a SQL query that acts like a SQLObject class. You define columns based on other SQLObject classes .q SQLBuilder columns, have columns that are aggregates of other columns, and join multiple SQLObject classes into one and add restrictions using SQLBuilder expressions. The resulting classes are currently read only, if you find use for this idea please bring discussion to the mailing list. A short example from the tests will suffice for now. Base classes:: class PhoneNumber(SQLObject): number = StringCol() calls = SQLMultipleJoin('PhoneCall') incoming = SQLMultipleJoin('PhoneCall', joinColumn='toID') class PhoneCall(SQLObject): phoneNumber = ForeignKey('PhoneNumber') to = ForeignKey('PhoneNumber') minutes = IntCol() View classes:: class ViewPhoneCall(ViewSQLObject): class sqlmeta: idName = PhoneCall.q.id clause = PhoneCall.q.phoneNumberID==PhoneNumber.q.id minutes = IntCol(dbName=PhoneCall.q.minutes) number = StringCol(dbName=PhoneNumber.q.number) phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id) call = ForeignKey('PhoneCall', dbName=PhoneCall.q.id) class ViewPhone(ViewSQLObject): class sqlmeta: idName = PhoneNumber.q.id clause = PhoneCall.q.phoneNumberID==PhoneNumber.q.id minutes = IntCol(dbName=func.SUM(PhoneCall.q.minutes)) numberOfCalls = IntCol(dbName=func.COUNT(PhoneCall.q.phoneNumberID)) number = StringCol(dbName=PhoneNumber.q.number) phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id) calls = SQLMultipleJoin('PhoneCall', joinColumn='phoneNumberID') vCalls = SQLMultipleJoin('ViewPhoneCall', joinColumn='phoneNumberID') .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/LICENSE0000644000175000017500000006364212224000136014607 0ustar phdphd00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! SQLObject-3.1.0/docs/europython/0000755000175000017500000000000012754657361016035 5ustar phdphd00000000000000SQLObject-3.1.0/docs/europython/main.css0000644000175000017500000000103710707101542017451 0ustar phdphd00000000000000BODY { margin-left: 1em; margin-right: 1em; border: 0px; padding: 0px; font-family: helvetica, ariel; color: #445566; } H1, H2 { font-family: helvetica; } PRE { padding: 5px; font-family: Courier Bold, Courier; border: thin black solid; background-color: #f5f5f5; font-size: medium; } HR { display: inline; } UL { padding: 0px; margin: 0px; margin-left: 1em; padding-left: 1em; border-left: 1em; } LI { padding: 2px; } .footer { position: absolute; bottom: 0.5em; text-align: right; } SQLObject-3.1.0/docs/europython/europython_sqlobj.py0000644000175000017500000002604510707101542022161 0ustar phdphd00000000000000#!/usr/bin/python2.2 from slides import Lecture, NumSlide, Slide, Bullet, SubBullet, PRE, URL lecture = Lecture( "High-Level Database Interaction with SQLObject", Slide("What is SQLObject?", Bullet("YAORM -- Yet Another Object-Relational Mapper"), Bullet("Allows you to map your Python classes to your database schema"), Bullet("Takes the 'SQL' out of 'Database Programming'"), Bullet("No special XML files to create, just normal Python classes")), Slide("Why Do I Care?", Bullet("Storing things in databases is fairly common in day-to-day programming"), Bullet("SQL is the standard language used to manipulate data in a database"), Bullet("Writing SQL is boring, repetitive and depressing"), Bullet("SQLObject relieves you of the burden of writing SQL"), Bullet("...but still lets you write SQL when you need to")), Slide("How does SQLObject differ from other ORM's?", Bullet("Simple is better than complex; SQLObject is very simple to use"), Bullet("Mappings are defined using normal Python classes"), Bullet("Uses properties instead of wordy get/set methods for column attributes"), Bullet("No awkward auto-generation of Python classes/files from an external format"), Bullet("Can generate the database schema directly from your Python classes, and vice versa"), Bullet("Overloading magic provides convenient high-level SQL conditionals (dot q magic, stay tuned)")), Slide("A Simple Example", Bullet("To create a table that looks like this in SQL:", PRE("""\ CREATE TABLE person ( id SERIAL, first_name VARCHAR(100) NOT NULL, middle_initial CHAR(1), last_name VARCHAR(150) NOT NULL );""")), Bullet("You would write this Python code:", PRE("""\ class Person(SQLObject): firstName = StringCol(length = 100) middleInitial = StringCol(length = 1) lastName = StringCol(length = 150)""")), Bullet("No, you're not dreaming :P")), Slide("Declaring the Class", PRE("""\ from SQLObject import * conn = PostgresConnection(db = 'testdb', user = 'testuser', password = 'testpass') class Person(SQLObject): _connection = conn firstName = StringCol(length = 100) middleInitial = StringCol(length = 1) lastName = StringCol(length = 150)"""), Bullet("Use one of MySQLConnection, PostgresConnection, SQLiteConnection or DBMConnection as your _connection"), Bullet("Use StudlyCaps for your classes and mixedCase for your columns"), Bullet("SQLObject will map TableName to table_name and columnName to column_name"), Bullet("In the above example, class Person becomes table person with columns first_name, middle_initial and last_name")), Slide("Creating and Dropping Tables", Bullet("Use the createTable class method to create the table, and two optional keyword arguments",SubBullet( Bullet("ifNotExists: only try to create the table if it doesn't exist"), Bullet("createJoinTables: will create the intermediate tables for many-to-many relationships"))), Bullet("Conversely, use dropTable, passing in optional ifExists and dropJoinTables keyword arguments")), Slide("More on Column Syntax", Bullet("Columns are implemented as properties"), Bullet("Columns supported: StringCol, IntCol, FloatCol, EnumCol, DateTimeCol, ForeignKey, DecimalCol, CurrencyCol"), Bullet("The first argument is the column name"), Bullet("Keyword arguments specify additional information (e.g. notNone, default, length, etc)"), Bullet("SQLObject lets the database do type checking and coercion"), Bullet("An id column is implicitly created")), Slide("Keyword Arguments for Col Classes", Bullet("dbName: the column name in the database"), Bullet("default: the default value (can be a callable that returns a value)"), Bullet("alternateID: set this to True if you want a byColumnName method to lookup rows based on this column"), Bullet("unique: declare this column as UNIQUE in the database"), Bullet("notNone: when True, column cannot be None/NULL"), Bullet("sqlType: to specify the column type manually")), Slide("Special Class Attributes", Bullet("_connection: the database connection for this class"), Bullet("_table: the database name of the table behind this class"), Bullet("_joins: a list of join relationships to other classes"), Bullet("_cacheValues: you'll want to set this false if you're using SQLObject classes from multiple processes"), Bullet("_idName: the name of the PK (defaults to id)"), Bullet("_style: a style object that provides a custom Python to DB name mapping algorithm")), Slide("Using SQLObject classes", Bullet("Create a new row with the .new() class method:", PRE("""Person.new(firstName = "Brad", middleInitial = "E", lastName = "Bollenbach")""")), Bullet("The row is inserted into the database as soon as you call .new()"), Bullet("Access an existing row by passing an ID to the class constructor", PRE("""\ >>> me = Person(1) >>> me.firstName 'Brad' >>> me.lastName 'Bollenbach'""")), Bullet("Modify column values by modifying property values"), Bullet("Changes to your object's properties are updated immediately in the database"), Bullet("...but transactions are there if you need them (as long as the database supports them)")), Slide("Relating Your Classes with Joins", Bullet("Use a ForeignKey to point a column's value at an instance of another class"), Bullet("To relate the PK class back to the FK class, use MultipleJoin"), Bullet("Let's give a Person some PhoneNumbers:", PRE("""\ from SQLObject import * conn = PostgresConnection(db = 'testdb', user = 'testuser', password = 'testpass') class Person(SQLObject): _connection = conn firstName = StringCol(length = 100) middleInitial = StringCol(length = 1) lastName = StringCol(length = 150) phoneNumbers = MultipleJoin("PhoneNumber") class PhoneNumber(SQLObject): _connection = conn person = ForeignKey('Person') phoneNumber = StringCol(length = 10)"""))), Slide("Many-to-Many Relationships", Bullet("A Person might have many Roles"), Bullet("A Role might be associated to more than one Person"), Bullet("Use a RelatedJoin to specify this many-to-many relation:", PRE("""\ class Role(SQLObject): _connection = conn name = StringCol(length = 20) people = RelatedJoin('Person') class Person(SQLObject): _connection = conn firstName = StringCol(length = 100) middleInitial = StringCol(length = 1) lastName = StringCol(length = 150) phoneNumbers = MultipleJoin("PhoneNumber") roles = RelatedJoin('Role') me = Person.new(firstName = "Brad", middleInitial = "E", lastName = "Bollenbach") pg = Role.new(name = "Python Geek") me.addRole(pg) """)), Bullet("SQLObject added .addRole() and .removeRole() methods to Person, and .addPerson() and .removePerson() methods to Role"), Bullet("...and created the person_role table by combining the table names of the classes alphabetically")), Slide("Selecting Multiple Objects", Bullet("The class's .select() method can be used to return multiple objects of a given class"), Bullet("Here comes that dot q magic!"), Bullet("Every SQLObject derived class has a special .q attribute, which uses some funky operator overloading to construct queries using Python:", PRE("""\ >>> from person import Person >>> brads = Person.select(Person.q.firstName == 'Brad') >>> list(brads) [] >>> brads[0].lastName 'Bollenbach' """)), Bullet("select accepts orderBy and groupBy arguments, which are strings (or lists of strings) referring to the database column name")), Slide("Selects using AND", Bullet("Use the AND function for more specific queries:", PRE("""\ >>> from SQLObject import AND >>> from person import Person >>> bradbs = Person.select(AND( ... Person.q.firstName == "Brad", ... Person.q.lastName.startswith("B") ... )) """)), Bullet("Notice that columns-as-properties behave much like their regular Python brethren (e.g. the startswith method used above)")), Slide("Customizing Column Behaviour", Bullet("SQLObject uses metaclasses to generate the classes that map to your database tables"), Bullet("Because of this, you need to take care when overriding property get/set methods"), Bullet("You cannot simply override the get or set method and then call the parent's get/set"), Bullet("Your class was created on-the-fly by SQLObject, so there is no parent! :)"), Bullet("SQLObject gives you special _SO_set_foo and _SO_get_foo methods to call after you've done something special in the normal setter/getter"), Bullet("An (admittedly contrived) example:", PRE("""\ class Person(SQLObject): ... def _set_lastName(self, value): print "you changed the lastName" self._SO_set_lastName(value) """))), Slide("Better Living Through Transactions", Bullet("Sometimes you need indivisibility"), Bullet("SQLObject lets you use transactions when the database supports it", PRE("""\ trans = Person._connection.transaction() me = Person(1, trans) me.firstName = "Bradley" trans.commit() me.firstName = "Yada" trans.rollback()"""))), Slide("Automatic Class Generation", Bullet("Laziness is a virtue"), Bullet("If you've already got a database schema, why not make SQLObject create the classes for you?", PRE("""\ class Person(SQLObject): _fromDatabase = True""")), Bullet("You can still specify additional columns, as normal"), Bullet("Currently this only works with MySQL")), Slide("SQLObject in the Wild -- Who's Using It?", Bullet("BBnet.ca used SQLObject to develop a time tracking and invoicing system for a consultancy firm"), Bullet("XSOLI (my current employer) is using SQLObject to drive an online merchant proxy system"), Bullet("Future projects will probably include porting a sales application for a fixed-rate long distance provider onto the SQLObject framework"), Bullet("There's an active community of SQLObject developers on the mailing list")), Slide("Future Plans for SQLObject", Bullet("Add support for more databases"), Bullet("Improved transaction handling, so that even non-transaction aware backends can support them"), Bullet("Hooks into a validation and form generation package"), Bullet("More powerful joins")), Slide("Summing Up", Bullet("SQLObject is a framework that can make your (programming) life easier"), Bullet("It provides a high-level Python interface to things you'd normally suffer through in SQL"), Bullet("It offers advanced features like automatic class generation, dot q magic, and various ways of relating your classes"), Bullet("There's an active developer base, so you're sure to find help when you need it")), Slide("Resources", Bullet("SQLObject homepage -- ", URL("http://www.sqlobject.org")), Bullet("Join the mailing list -- ", URL("http://lists.sourceforge.net/lists/listinfo/sqlobject-discuss")), Bullet("Contact me -- brad@bbnet.ca")), Slide("Questions?", Bullet("Questions?"), Bullet("Comments?"), Bullet("Free beer?"))) lecture.renderHTML(".", "slide-%02d.html", css="main.css") SQLObject-3.1.0/docs/europython/person.py0000644000175000017500000000121110707101542017665 0ustar phdphd00000000000000from SQLObject import * conn = PostgresConnection(db = 'merchant_test', user = 'merchant_test', password = 'mtest') class Role(SQLObject): _connection = conn name = StringCol(length = 20) people = RelatedJoin('Person') class Person(SQLObject): _cacheValues = False _connection = conn firstName = StringCol(length = 100) middleInitial = StringCol(length = 1) lastName = StringCol(length = 150) phoneNumbers = MultipleJoin("PhoneNumber") roles = RelatedJoin('Role') class PhoneNumber(SQLObject): _connection = conn person = ForeignKey('Person') phoneNumber = StringCol(length = 10) SQLObject-3.1.0/docs/Inheritance.rst0000644000175000017500000002602512753243417016601 0ustar phdphd00000000000000:Author: Daniel Savard, XSOLI Inc. .. contents:: Inheritance ----------- Why ~~~ Imagine you have a list of persons, and every person plays a certain role. Some persons are students, some are professors, some are employees. Every role has different attributes. Students are known by their department and year. Professors have a department (some attributes are common for all or some roles), timetable and other attributes. How does one implement this in SQLObject? Well, the obvious approach is to create a table Person with a column that describes or name the role, and a table for an every role. Then one must write code that interprets and dereferences the role column. Well, the inheritance machinery described below does exactly this! Only it does it automagically and mostly transparent to the user. First, you create a table Person. Nothing magical here:: class Person(SQLObject): name = StringCol() age = FloatCol() Now you need a hierarchy of roles:: class Role(InheritableSQLObject): department = StringCol() The magic starts here! You inherit the class from the special root class ``InheritableSQLObject`` and provide a set of attributes common for all roles. Other roles must be inherited from Role:: class Student(Role): year = IntCol() class Professor(Role): timetable = StringCol() Now you want a column in Person that can be interpreted as the role. Easy:: class Person(SQLObject): name = StringCol() age = FloatCol() role = ForeignKey("Role") That's all, really! When asked for its role, Person returns the value of its .role attribute dereferenced and interpreted. Instead of returning an instance of class Role it returns an instance of the corresponding subclass - a Student or a Professor. This is a brief explanation based on a task people meet most often, but of course it can be used far beyond the person/role task. I also omitted all details in the explanation. Now look at the real working program:: from sqlobject import * from sqlobject.inheritance import InheritableSQLObject __connection__ = "sqlite:/:memory:" class Role(InheritableSQLObject): department = StringCol() class Student(Role): year = IntCol() class Professor(Role): timetable = StringCol(default=None) class Person(SQLObject): name = StringCol() age = FloatCol() role = ForeignKey("Role", default=None) Role.createTable() Student.createTable() Professor.createTable() Person.createTable() first_year = Student(department="CS", year=1) lecturer = Professor(department="Mathematics") student = Person(name="A student", age=21, role=first_year) professor = Person(name="A professor", age=42, role=lecturer) print student.role print professor.role It prints:: You can get the list of all available roles:: print list(Role.select()) It prints:: [, ] Look - you have gotten a list of Role's subclasses! If you add a MultipleJoin column to Role, you can list all persons for a given role:: class Role(InheritableSQLObject): department = StringCol() persons = MultipleJoin("Person") for role in Role.select(): print role.persons It prints:: [] [] If you you want your persons to have many roles, use RelatedJoin:: class Role(InheritableSQLObject): department = StringCol() persons = RelatedJoin("Person") class Student(Role): year = IntCol() class Professor(Role): timetable = StringCol(default=None) class Person(SQLObject): name = StringCol() age = FloatCol() roles = RelatedJoin("Role") Role.createTable() Student.createTable() Professor.createTable() Person.createTable() first_year = Student(department="CS", year=1) lecturer = Professor(department="Mathematics") student = Person(name="A student", age=21) student.addRole(first_year) professor = Person(name="A professor", age=42) professor.addRole(lecturer) print student.roles print professor.roles for role in Role.select(): print role.persons It prints:: [] [] [] [] Who, What and How ~~~~~~~~~~~~~~~~~ Daniel Savard has implemented inheritance for SQLObject. In `terms of ORM`_ this is a kind of vertical inheritance. The only difference is that objects reference their leaves, not parents. Links to parents are reconstructed at run-time using the hierarchy of Python classes. .. _`terms of ORM`: https://cayenne.apache.org/docs/3.0/modeling-inheritance.html * As suggested by Ian Bicking, each child class now has the same ID as the parent class. No more need for childID column and parent foreignKey (and a small speed boost). * No more need to call getSubClass, as the 'latest' child will always be returned when an instance of a class is created. * This version now seems to work correctly with addColumn, delColumn, addJoin and delJoin. The following code:: from sqlobject.inheritance import InheritableSQLObject class Person(InheritableSQLObject): firstName = StringCol() lastName = StringCol() class Employee(Person): _inheritable = False position = StringCol() will generate the following tables:: CREATE TABLE person ( id INT PRIMARY KEY, child_name TEXT, first_name TEXT, last_name TEXT ); CREATE TABLE employee ( id INT PRIMARY KEY, position TEXT ) A new class attribute ``_inheritable`` is added. When this new attribute is set to 1, the class is marked 'inheritable' and a new columns will automatically be added: childName (TEXT). Each class that inherits from a parent class will get the same ID as the parent class. So, there is no need to keep track of parent ID and child ID, as they are the same. The column childName will contain the name of the child class (for example 'Employee'). This will permit a class to always return its child class if available (a person that is also an employee will always return an instance of the employee class). For example, the following code:: p = Person(firstName='John', lastName='Doe') e = Employee(firstName='Jane', lastName='Doe', position='Chief') p2 = Person.get(1) Will create the following data in the database:: *Person* id child_name first_name last_name 0 Null John Doe 1 Employee Jane Doe *Employee* id position 1 Chief You will still be able to ask for the attribute normally: e.firstName will return Jane and setting it will write the new value in the person table. If you use p2, as p2 is a person object, you will get an employee object. person(0) will return a Person instance and will have the following attributes: firstName and lastName. person(1) or employee(1) will both return the same Employee instance and will have the following attributes: firstName, lastName and position. Also, deleting a person or an employee that is linked will destroy both entries as one would expect. The SQLObject q magic also works. Using these selects is valid:: Employee.select(AND(Employee.q.firstName == 'Jane', Employee.q.position == 'Chief')) will return Jane Doe Employee.select(AND(Person.q.firstName == 'Jane', Employee.q.position == 'Chief')) will return Jane Doe Employee.select(Employee.q.lastName == 'Doe') will only return Jane Doe (as Joe isn't an employee) Person.select(Person.q.lastName == 'Doe') will return both entries. The SQL 'where' clause will contain additional clauses when used with 'inherited' classes. These clauses are the link between the id and the parent id. This will look like the following request:: SELECT employee.id, person.first_name, person.last_name FROM person, employee WHERE person.first_name = 'Jane' AND employee.position = 'Chief' AND person.id = employee.id Limitations and notes ~~~~~~~~~~~~~~~~~~~~~ * Only single inheritance will work. It is not possible to inherit from multiple SQLObject classes. * It is possible to inherit from an inherited class and this will work well. In the above example, you can have a Chief class that inherits from Employee and all parents attributes will be available through the Chief class. * You may not redefine columns in an inherited class (this will raise an exception). * If you don't want 'childName' columns in your last class (one that will never be inherited), you must set '_inheritable' to False in this class. * The inheritance implementation is incompatible with lazy updates. Do not set lazyUpdate to True. If you need this, you have to patch SQLObject and override many methods - _SO_setValue(), sync(), syncUpdate() at least. Patches will be gladly accepted. * You'd better restrain yourself to simple use cases. The inheritance implementation is easily choked on more complex cases. * A join between tables inherited from the same parent produces incorrect result due to joins to the same parent table (they must use different aliases). * Inheritance works in two stages - first it draws the IDs from the parent table and then it draws the rows from the children tables. The first stage could fail if you try to do complex things. For example, Children.select(orderBy=Children.q.column, distinct=True) could fail because at the first stage inheritance generates a SELECT query for the parent table with ORDER BY the column from the children table. * I made it because I needed to be able to have automatic inheritance with linked tables. * This version works for me; it may not work for you. I tried to do my best but it is possible that I broke some things... So, there is no warranty that this version will work. * Thanks to Ian Bicking for SQLObject; this is a wonderful python module. * Although all the attributes are inherited, the same does not apply to sqlmeta data. Don't try to get a parent column via the sqlmeta.columns dictionary of an inherited InheritableSQLObject: it will raise a KeyError. The same applies to joins: the sqlmeta.joins list will be empty in an inherited InheritableSQLObject if a join has been defined in the parent class, even though the join method will work correctly. * If you have suggestion, bugs, or patch to this patch, you can contact the SQLObject team: .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/index.rst0000644000175000017500000000411512753245642015455 0ustar phdphd00000000000000+++++++++ SQLObject +++++++++ SQLObject is a popular *Object Relational Manager* for providing an object interface to your database, with tables as classes, rows as instances, and columns as attributes. SQLObject includes a Python-object-based query language that makes SQL more abstract, and provides substantial database independence for applications. Documentation ============= * `Download `_ * `Mailing list, bugs, etc. `_ * `Related projects and articles `_ * `News and updates `_ * `SQLObject and Python 3 `_ * `Main SQLObject documentation `_ * `Frequently Asked Questions `_ * `sqlbuilder documentation `_ * `select() and SelectResults `_ * `sqlobject-admin documentation `_ * `Inheritance `_ * `Versioning `_ * `Views `_ * `Developer Guide `_ * `Contributors `_ * `TODO `_ Example ======= This is just a snippet that creates a simple class that wraps a table:: >>> from sqlobject import * >>> >>> sqlhub.processConnection = connectionForURI('sqlite:/:memory:') >>> >>> class Person(SQLObject): ... fname = StringCol() ... mi = StringCol(length=1, default=None) ... lname = StringCol() ... >>> Person.createTable() SQLObject supports most database schemas that you already have, and can also issue the ``CREATE`` statement for you (seen in ``Person.createTable()``). Here's how you'd use the object:: >>> p = Person(fname="John", lname="Doe") >>> p >>> p.fname 'John' >>> p.mi = 'Q' >>> p2 = Person.get(1) >>> p2 >>> p is p2 True .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/html/0000755000175000017500000000000012754657361014565 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/Views.html0000644000175000017500000001046212754657232016550 0ustar phdphd00000000000000 Views and SQLObjects

Views and SQLObjects

In general, if your database backend supports defining views you may define them outside of SQLObject and treat them as a regular table when defining your SQLObject class.

ViewSQLObject

The rest of this document is experimental.

from sqlobject.views import *

ViewSQLObject is an attempt to allow defining views that allow you to define a SQL query that acts like a SQLObject class. You define columns based on other SQLObject classes .q SQLBuilder columns, have columns that are aggregates of other columns, and join multiple SQLObject classes into one and add restrictions using SQLBuilder expressions.

The resulting classes are currently read only, if you find use for this idea please bring discussion to the mailing list.

A short example from the tests will suffice for now.

Base classes:

class PhoneNumber(SQLObject):
  number = StringCol()
  calls = SQLMultipleJoin('PhoneCall')
  incoming = SQLMultipleJoin('PhoneCall', joinColumn='toID')

class PhoneCall(SQLObject):
  phoneNumber = ForeignKey('PhoneNumber')
  to = ForeignKey('PhoneNumber')
  minutes = IntCol()

View classes:

class ViewPhoneCall(ViewSQLObject):
  class sqlmeta:
      idName = PhoneCall.q.id
      clause = PhoneCall.q.phoneNumberID==PhoneNumber.q.id

  minutes = IntCol(dbName=PhoneCall.q.minutes)
  number = StringCol(dbName=PhoneNumber.q.number)
  phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id)
  call = ForeignKey('PhoneCall', dbName=PhoneCall.q.id)

class ViewPhone(ViewSQLObject):
  class sqlmeta:
      idName = PhoneNumber.q.id
      clause = PhoneCall.q.phoneNumberID==PhoneNumber.q.id

  minutes = IntCol(dbName=func.SUM(PhoneCall.q.minutes))
  numberOfCalls = IntCol(dbName=func.COUNT(PhoneCall.q.phoneNumberID))
  number = StringCol(dbName=PhoneNumber.q.number)
  phoneNumber = ForeignKey('PhoneNumber', dbName=PhoneNumber.q.id)
  calls = SQLMultipleJoin('PhoneCall', joinColumn='phoneNumberID')
  vCalls = SQLMultipleJoin('ViewPhoneCall', joinColumn='phoneNumberID')
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.boundattributes.html0000644000175000017500000001120512754657335024141 0ustar phdphd00000000000000

boundattributes

Bound attributes are attributes that are bound to a specific class and a specific name. In SQLObject a typical example is a column object, which knows its name and class.

The boundattributes module is accessible via the sqlobject module.

A bound attribute should define a method __addtoclass__(added_class, name) (attributes without this method will simply be treated as normal). The return value is ignored; if the attribute wishes to change the value in the class, it must call setattr(added_class, name, new_value).

BoundAttribute is a class that facilitates lazy attribute creation.

Attributes

a __package__

'sqlobject'

Classes

C BoundAttribute(...) ...

This is a declarative class that passes all the values given to it to another object. So you can pass it arguments (via __init__/__call__) or give it the equivalent of keyword arguments through subclassing. Then a bound object will be added in its place.

To hook this other object in, override make_object(added_class, name, **attrs) and maybe set_object(added_class, name, **attrs) (the default implementation of set_object just resets the attribute to whatever make_object returned).

Also see BoundFactory.

This class contains 16 members.

C BoundFactory(...) ...

This will bind the attribute to whatever is given by factory_class. This factory should be a callable with the signature factory_class(added_class, attr_name, *args, **kw).

The factory will be reinvoked (and the attribute rebound) for every subclassing.

This class contains 17 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.DeleteColumnSignal.html0000644000175000017500000000742412754657341025571 0ustar phdphd00000000000000

DeleteColumnSignal

Called when a column is removed from a class, with the arguments (cls, connection, column_name, so_column_obj, post_funcs). Like AddColumnSignal this is called after the action has been performed, and is called for subclassing (when a column is implicitly removed by setting it to None).

The DeleteColumnSignal class is accessible via the sqlobject.events module.

post_funcs are called with (cls, so_column_obj)

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sresults-index.html0000644000175000017500000002272612754657344023726 0ustar phdphd00000000000000 Index of sqlobject.sresults module

Index of the sresults module

SQLObject-3.1.0/docs/html/class-sqlobject.events.RowUpdatedSignal.html0000644000175000017500000000734312754657342025270 0ustar phdphd00000000000000

RowUpdatedSignal

Called when an instance is updated through a call to .set() (or a column attribute assignment). The arguments are (instance, post_funcs). post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance). This is run after the instance is updated; Works better with lazyUpdate = True.

The RowUpdatedSignal class is accessible via the sqlobject.events module.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.TimestampCol.html0000644000175000017500000000755212754657346023734 0ustar phdphd00000000000000

TimestampCol

The TimestampCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.ConnMethodWrapper.html0000644000175000017500000000714612754657340026613 0ustar phdphd00000000000000

ConnMethodWrapper

The ConnMethodWrapper class is accessible via the sqlobject.dbconnection module.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, method, connection) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.joins.html0000644000175000017500000001257412754657352022056 0ustar phdphd00000000000000

joins

The joins module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Classes

C MultipleJoin(...) ...

This class contains 8 members.

C SQLMultipleJoin(...) ...

This class contains 8 members.

C RelatedJoin(...) ...

This class contains 8 members.

C SQLRelatedJoin(...) ...

This class contains 8 members.

C SingleJoin(...) ...

This class contains 8 members.

C ManyToMany(...) ...

This class contains 19 members.

C OneToMany(...) ...

This class contains 16 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.LIKE.html0000644000175000017500000004150712754657327023445 0ustar phdphd00000000000000

LIKE

The LIKE class is accessible via the sqlobject.sqlbuilder module.

Attributes

a op

'LIKE'

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, expr, string, escape=None) ...

f __sqlrepr__(self, db) ...

f components(self) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SODateCol.html0000644000175000017500000002427212754657351023102 0ustar phdphd00000000000000

SODateCol

The SODateCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a dateFormat

'%Y-%m-%d'

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f createValidators(self) ...

Create a validator for the column.

Can be overriden in descendants.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.ProgrammingError.html0000644000175000017500000001336612754657323025667 0ustar phdphd00000000000000

ProgrammingError

The ProgrammingError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.RowCreateSignal.html0000644000175000017500000000754212754657341025105 0ustar phdphd00000000000000

RowCreateSignal

Called before an instance is created, with the class as the sender. Called with the arguments (instance, kwargs, post_funcs). There may be a connection argument. kwargs``may be usefully modified.  ``post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance).

The RowCreateSignal class is accessible via the sqlobject.events module.

Note: this is not called when an instance is created from an existing database row.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.FloatCol.html0000644000175000017500000000750312754657350023025 0ustar phdphd00000000000000

FloatCol

The FloatCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLJoinConditional.html0000644000175000017500000004210612754657332026354 0ustar phdphd00000000000000

SQLJoinConditional

Conditional JOIN

The SQLJoinConditional class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table1, table2, op, on_condition=None, using_columns=None) ...

For condition you must give on_condition or using_columns but not both

on_condition can be a string or SQLExpression, for example
Table1.q.col1 == Table2.q.col2
using_columns can be a string or a list of columns, e.g.
(Table1.q.col1, Table2.q.col2)

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.main.SQLObjectNotFound.html0000644000175000017500000001330612754657334024734 0ustar phdphd00000000000000

SQLObjectNotFound

The SQLObjectNotFound class is accessible via the sqlobject.main module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.inheritance-index.html0000644000175000017500000002675112754657344024335 0ustar phdphd00000000000000 Index of sqlobject.inheritance module

Index of the inheritance module

SQLObject-3.1.0/docs/html/module-sqlobject.maxdb.maxdbconnection.html0000644000175000017500000001476412754657343025204 0ustar phdphd00000000000000

maxdbconnection

Contributed by Edigram SAS, Paris France Tel:01 44 77 94 00 Ahmed MOHAMED ALI <ahmedmoali@yahoo.com> 27 April 2004

The maxdbconnection module is accessible via the sqlobject.maxdb module.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

connection creation sample:

__connection__ = DBConnection.maxdbConnection(
    host=hostname, database=dbname,
    user=user_name, password=user_password, autoCommit=1, debug=1)

Attributes

a __package__

'sqlobject.maxdb'

a SAPDBMAX_ID_LENGTH

32

Classes

C maxdbException(...) ...

This class contains 10 members.

C LowerBoundOfSliceIsNotSupported(...) ...

This class contains 10 members.

C IncorrectIDStyleError(...) ...

This class contains 10 members.

C StyleMismatchError(...) ...

This class contains 10 members.

C PrimaryKeyNotFounded(...) ...

This class contains 10 members.

C MaxdbConnection(...) ...

This class contains 22 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.postgres.pgconnection.PostgresConnection.html0000644000175000017500000002567312754657320030733 0ustar phdphd00000000000000

PostgresConnection

The PostgresConnection class is accessible via the sqlobject.postgres.pgconnection module.

Attributes

a supportTransactions

True

a schemes

['postgres', 'postgresql']

a dbName

'postgres'

Methods

f __init__(self, dsn=None, host=None, port=None, db=None, user=None, password=None, **kw) ...

f makeConnection(self) ...

f createColumn(self, soClass, col) ...

f createReferenceConstraint(self, soClass, col) ...

f createIndexSQL(self, soClass, index) ...

f createIDColumn(self, soClass) ...

f dropTable(self, tableName, cascade=False) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f addColumn(self, tableName, column) ...

f delColumn(self, sqlmeta, column) ...

f columnsFromSchema(self, tableName, soClass) ...

f guessClass(self, t) ...

f defaultFromSchema(self, colClass, defaultstr) ...

If the default can be converted to a python constant, convert it. Otherwise return is as a sqlbuilder constant.

f listTables(self) ...

f listDatabases(self) ...

f createEmptyDatabase(self) ...

f dropDatabase(self) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandRecord.html0000644000175000017500000004437412754657314026320 0ustar phdphd00000000000000

CommandRecord

The CommandRecord class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

'Record state of table definitions.  The state of each table is written out to a separate file in a directory, and that directory forms a "version".  A table is also added to your database (sqlobject_db_version) that reflects the version the database is currently at.  Use the upgrade command to sync databases with code.'

a parser

<optparse.OptionParser instance at 0xb64e78ac>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'record'

a summary

'Record historical information about the database status'

a min_args_error

'You must provide at least %(min_args)s arguments'

a version_regex

<_sre.SRE_Pattern object at 0xb64e9120>

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

f update_db(self, version, conn) ...

f strip_comments(self, sql) ...

f base_dir(self) ...

f find_output_dir(self) ...

f find_last_version(self) ...

f command_force_db_version(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.manager-index.html0000644000175000017500000011562012754657306023446 0ustar phdphd00000000000000 Index of sqlobject.manager module

Index of the manager module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.VersionError.html0000644000175000017500000001334412754657330025350 0ustar phdphd00000000000000

VersionError

The VersionError class is accessible via the sqlobject.sqlbuilder module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.RowCreatedSignal.html0000644000175000017500000000755112754657341025251 0ustar phdphd00000000000000

RowCreatedSignal

Called after an instance is created, with the class as the sender. Called with the arguments (instance, kwargs, post_funcs). There may be a connection argument. kwargs``may be usefully modified.  ``post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance).

The RowCreatedSignal class is accessible via the sqlobject.events module.

Note: this is not called when an instance is created from an existing database row.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.rdbhost-index.html0000644000175000017500000001106612754657323023477 0ustar phdphd00000000000000 Index of sqlobject.rdbhost module

Index of the rdbhost module

SQLObject-3.1.0/docs/html/class-sqlobject.joins.ManyToMany.html0000644000175000017500000002025612754657353023726 0ustar phdphd00000000000000

ManyToMany

The ManyToMany class is accessible via the sqlobject.joins module.

Attributes

a singleton

<bound class method ManyToMany.singleton>

a clone_for_subclass

True

a intermediateTable

None

a otherColumn

None

a createJoinTable

True

a declarative_count

3

a __unpackargs__

('join',)

a joinColumn

None

a __addtoclass__

<bound class method ManyToMany.__addtoclass__>

a __restrict_attributes__

('join', 'intermediateTable', 'joinColumn', 'otherColumn', 'createJoinTable')

a __mutableattributes__

()

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __classinit__(cls, new_attrs) ...

f __instanceinit__(self, new_attrs) ...

f __init__(self, *args, **kw) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOSetCol.html0000644000175000017500000002334212754657347022762 0ustar phdphd00000000000000

SOSetCol

The SOSetCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.html0000644000175000017500000002331012754657233020721 0ustar phdphd00000000000000

sqlobject

SQLObject

Attributes

a sqlhub

<sqlobject.dbconnection.ConnectionHub object at 0xb65baaac>

a func

<sqlobject.sqlbuilder.ConstantSpace instance at 0xb6749c6c>

a const

<sqlobject.sqlbuilder.ConstantSpace instance at 0xb6749c6c>

a default_datetime_implementation

'datetime'

a DATETIME_IMPLEMENTATION

'datetime'

a mxdatetime_available

True

a MXDATETIME_IMPLEMENTATION

'mxDateTime'

a datetime_available

True

a version

'3.1.0'

a __package__

'sqlobject'

a version_info

(3, 1, 0, 'final', 0)

Modules

The sqlobject module exposes 32 submodules:

__version__
boundattributes
Bound attributes are attributes that are bound to a specific class and a specific name. In SQLObject a typical example is a column object, which knows its name and class.
cache
This implements the instance caching in SQLObject. Caching is relatively aggressive. All objects are retained so long as they are in memory, by keeping weak references to objects. We also keep other objects in a cache that doesn't allow them to be garbage collected (unless caching is turned off).
classregistry
classresolver.py
2 February 2004, Ian Bicking <ianb@colorstudy.com>
col
Col -- SQLObject columns
compat
constraints
Constraints
converters
dbconnection
dberrors
dberrors: database exception classes for SQLObject.
declarative
Declarative objects.
events
firebird
include
index
inheritance
joins
main
manager
maxdb
mssql
mysql
postgres
rdbhost
sqlbuilder
sqlite
sresults
styles
sybase
util
versioning
views

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.inheritance.html0000644000175000017500000000445212754657344023222 0ustar phdphd00000000000000

inheritance

The inheritance module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.inheritance'

Classes

C InheritableSQLObject(...) ...

This class contains 24 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.maxdb.maxdbconnection.StyleMismatchError.html0000644000175000017500000001361112754657343030611 0ustar phdphd00000000000000

StyleMismatchError

The StyleMismatchError class is accessible via the sqlobject.maxdb.maxdbconnection module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.constraints.MaxLength.html0000644000175000017500000000353312754657323025002 0ustar phdphd00000000000000

MaxLength

The MaxLength class is accessible via the sqlobject.constraints module.

Methods

f __init__(self, length) ...

f __call__(self, obj, col, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.converters.html0000644000175000017500000003133512754657334023122 0ustar phdphd00000000000000

converters

The converters module is accessible via the sqlobject module.

Attributes

a PY2

True

a NumericType

None

a __package__

'sqlobject'

a converters

<sqlobject.converters.ConverterRegistry instance at 0xb601696c>

a sqlStringReplace

[("'", "''"),
 ('\\', '\\\\'),
 ('\x00', '\\0'),
 ('\x08', '\\b'),
 ('\n', '\\n'),
 ('\r', '\\r'),
 ('\t', '\\t')]

Functions

f registerConverter(self, typ, func) ...

f lookupConverter(self, value, default=None) ...

f StringLikeConverter(value, db) ...

f IntConverter(value, db) ...

f LongConverter(value, db) ...

f BoolConverter(value, db) ...

f FloatConverter(value, db) ...

f mxDateTimeConverter(value, db) ...

f mxTimeConverter(value, db) ...

f NoneConverter(value, db) ...

f SequenceConverter(value, db) ...

f StructTimeConverter(value, db) ...

f DateTimeConverter(value, db) ...

f DateTimeConverterMS(value, db) ...

f DateConverter(value, db) ...

f TimeConverter(value, db) ...

f TimeConverterMS(value, db) ...

f DecimalConverter(value, db) ...

f TimedeltaConverter(value, db) ...

f sqlrepr(obj, db=None) ...

f quote_str(s, db) ...

f unquote_str(s) ...

Classes

C ConverterRegistry(...) ...

This class contains 3 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.CurrencyCol.html0000644000175000017500000000754212754657347023563 0ustar phdphd00000000000000

CurrencyCol

The CurrencyCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandSQL.html0000644000175000017500000003552012754657313025531 0ustar phdphd00000000000000

CommandSQL

The CommandSQL class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

''

a parser

<optparse.OptionParser instance at 0xb64d6f4c>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'sql'

a summary

'Show SQL CREATE statements'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.events.html0000644000175000017500000004313012754657341022226 0ustar phdphd00000000000000

events

The events module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Functions

f listen(receiver, soClass, signal, alsoSubclasses=True, weak=True) ...

Listen for the given signal on the SQLObject subclass soClass, calling receiver() when send(soClass, signal, ...) is called.

If alsoSubclasses is true, receiver will also be called when an event is fired on any subclass.

f send(signal=_Any, sender=_Anonymous, *arguments, **named) ...

Send signal from sender to all connected receivers.

signal -- (hashable) signal value, see connect for details

sender -- the sender of the signal

if Any, only receivers registered for Any will receive the message.

if Anonymous, only receivers registered to receive messages from Anonymous or Any will receive the message

Otherwise can be any python object (normally one registered with a connect if you actually want something to occur).

arguments -- positional arguments which will be passed to
all receivers. Note that this may raise TypeErrors if the receivers do not allow the particular arguments. Note also that arguments are applied before named arguments, so they should be used with care.
named -- named arguments which will be filtered according
to the parameters of the receivers to only provide those acceptable to the receiver.

Return a list of tuple pairs [(receiver, response), ... ]

if any receiver raises an error, the error propagates back through send, terminating the dispatch loop, so it is quite possible to not have all receivers called if a raises an error.

Classes

C Signal(...) ...

Base event for all SQLObject events.

In general the sender for these methods is the class, not the instance.

This class contains 4 members.

C ClassCreateSignal(...) ...

Signal raised after class creation. The sender is the superclass (in case of multiple superclasses, the first superclass). The arguments are (new_class_name, bases, new_attrs, post_funcs, early_funcs). new_attrs is a dictionary and may be modified (but new_class_name and bases are immutable). post_funcs is an initially-empty list that can have callbacks appended to it.

Note: at the time this event is called, the new class has not yet been created. The functions in post_funcs will be called after the class is created, with the single arguments of (new_class). Also, early_funcs will be called at the soonest possible time after class creation (post_funcs is called after the class's __classinit__).

This class contains 4 members.

C RowCreateSignal(...) ...

Called before an instance is created, with the class as the sender. Called with the arguments (instance, kwargs, post_funcs). There may be a connection argument. kwargs``may be usefully modified.  ``post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance).

Note: this is not called when an instance is created from an existing database row.

This class contains 4 members.

C RowCreatedSignal(...) ...

Called after an instance is created, with the class as the sender. Called with the arguments (instance, kwargs, post_funcs). There may be a connection argument. kwargs``may be usefully modified.  ``post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance).

Note: this is not called when an instance is created from an existing database row.

This class contains 4 members.

C RowDestroySignal(...) ...

Called before an instance is deleted. Sender is the instance's class. Arguments are (instance, post_funcs).

post_funcs is a list of callbacks, intended to have functions appended to it, and are called with arguments (instance). If any of the post_funcs raises an exception, the deletion is only affected if this will prevent a commit.

You cannot cancel the delete, but you can raise an exception (which will probably cancel the delete, but also cause an uncaught exception if not expected).

Note: this is not called when an instance is destroyed through garbage collection.

@@: Should this allow instance to be a primary key, so that a row can be deleted without first fetching it?

This class contains 4 members.

C RowDestroyedSignal(...) ...

Called after an instance is deleted. Sender is the instance's class. Arguments are (instance).

This is called before the post_funcs of RowDestroySignal

Note: this is not called when an instance is destroyed through garbage collection.

This class contains 4 members.

C RowUpdateSignal(...) ...

Called when an instance is updated through a call to .set() (or a column attribute assignment). The arguments are (instance, kwargs). kwargs can be modified. This is run before the instance is updated; if you want to look at the current values, simply look at instance.

This class contains 4 members.

C RowUpdatedSignal(...) ...

Called when an instance is updated through a call to .set() (or a column attribute assignment). The arguments are (instance, post_funcs). post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance). This is run after the instance is updated; Works better with lazyUpdate = True.

This class contains 4 members.

C AddColumnSignal(...) ...

Called when a column is added to a class, with arguments (cls, connection, column_name, column_definition, changeSchema, post_funcs). This is called after the column has been added, and is called for each column after class creation.

post_funcs are called with (cls, so_column_obj)

This class contains 4 members.

C DeleteColumnSignal(...) ...

Called when a column is removed from a class, with the arguments (cls, connection, column_name, so_column_obj, post_funcs). Like AddColumnSignal this is called after the action has been performed, and is called for subclassing (when a column is implicitly removed by setting it to None).

post_funcs are called with (cls, so_column_obj)

This class contains 4 members.

C CreateTableSignal(...) ...

Called when a table is created. If ifNotExists==True and the table exists, this event is not called.

Called with (cls, connection, extra_sql, post_funcs). extra_sql is a list (which can be appended to) of extra SQL statements to be run after the table is created. post_funcs functions are called with (cls, connection) after the table has been created. Those functions are not called simply when constructing the SQL.

This class contains 4 members.

C DropTableSignal(...) ...

Called when a table is dropped. If ifExists==True and the table doesn't exist, this event is not called.

Called with (cls, connection, extra_sql, post_funcs). post_funcs functions are called with (cls, connection) after the table has been dropped.

This class contains 4 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.boundattributes.BoundFactory.html0000644000175000017500000002124512754657335026364 0ustar phdphd00000000000000

BoundFactory

This will bind the attribute to whatever is given by factory_class. This factory should be a callable with the signature factory_class(added_class, attr_name, *args, **kw).

The BoundFactory class is accessible via the sqlobject.boundattributes module.

The factory will be reinvoked (and the attribute rebound) for every subclassing.

Attributes

a clone_for_subclass

True

a __unpackargs__

()

a __addtoclass__

<bound class method BoundFactory.__addtoclass__>

a factory_class

None

a singleton

<bound class method BoundFactory.singleton>

a __mutableattributes__

()

a __restrict_attributes__

None

a declarative_count

2

Methods

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __format__(...) ...

default object formatter

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __classinit__(cls, new_attrs) ...

f __instanceinit__(self, new_attrs) ...

f set_object(cls, added_class, attr_name, obj) ...

f make_object(cls, added_class, attr_name, *args, **kw) ...

f __init__(self, *args, **kw) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.DBConnection.html0000644000175000017500000001054412754657337025523 0ustar phdphd00000000000000

DBConnection

The DBConnection class is accessible via the sqlobject.dbconnection module.

Methods

f __init__(self, name=None, debug=False, debugOutput=False, cache=True, style=None, autoCommit=True, debugThreading=False, registry=None, logger=None, loglevel=None) ...

f oldUri(self) ...

f uri(self) ...

f connectionFromOldURI(cls, uri) ...

f connectionFromURI(cls, uri) ...

f soClassAdded(self, soClass) ...

This is called for each new class; we use this opportunity to create an instance method that is bound to the class and this connection.

f expireAll(self) ...

Expire all instances of objects for this connection.

See the source for more information.

SQLObject-3.1.0/docs/html/sqlobject/0000755000175000017500000000000012754657361016553 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/mysql/0000755000175000017500000000000012754657361017720 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/mysql/__init__.py.html0000644000175000017500000000725312464733165022776 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/mysql/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import mysqlconnection
0006    return mysqlconnection.MySQLConnection
0007
0008registerConnection(['mysql'], builder)
SQLObject-3.1.0/docs/html/sqlobject/postgres/0000755000175000017500000000000012754657361020421 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/postgres/__init__.py.html0000644000175000017500000000747312464733165023503 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/postgres/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import pgconnection
0006    return pgconnection.PostgresConnection
0007
0008registerConnection(['postgres', 'postgresql', 'psycopg'], builder)
SQLObject-3.1.0/docs/html/sqlobject/dberrors.py.html0000644000175000017500000002122312747416061021702 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/dberrors.py
0001"""dberrors: database exception classes for SQLObject.
0002
0003   These classes are dictated by the DB API v2.0, see:
0004   https://wiki.python.org/moin/DatabaseProgramming
0005"""
0006
0007from sqlobject.compat import PY2
0008
0009if not PY2:
0010    StandardError = Exception
0011
0012
0013class Error(StandardError):
0014    pass
0015
0016
0017class Warning(StandardError):
0018    pass
0019
0020
0021class InterfaceError(Error):
0022    pass
0023
0024
0025class DatabaseError(Error):
0026    pass
0027
0028
0029class InternalError(DatabaseError):
0030    pass
0031
0032
0033class OperationalError(DatabaseError):
0034    pass
0035
0036
0037class ProgrammingError(DatabaseError):
0038    pass
0039
0040
0041class IntegrityError(DatabaseError):
0042    pass
0043
0044
0045class DataError(DatabaseError):
0046    pass
0047
0048
0049class NotSupportedError(DatabaseError):
0050    pass
0051
0052
0053class DuplicateEntryError(IntegrityError):
0054    pass
SQLObject-3.1.0/docs/html/sqlobject/__init__.py.html0000644000175000017500000001371712464226042021622 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/__init__.py
0001"""SQLObject"""
0002
0003# Do import for namespace
0004# noqa is a directive for flake8 to ignore seemingly unused imports
0005
0006from .__version__ import version, version_info  # noqa
0007
0008from .col import *  # noqa
0009from .index import *  # noqa
0010from .joins import *  # noqa
0011from .main import *  # noqa
0012from .sqlbuilder import AND, OR, NOT, IN, LIKE, RLIKE, DESC, CONTAINSSTRING, const, func  # noqa
0013from .styles import *  # noqa
0014from .dbconnection import connectionForURI  # noqa
0015from . import dberrors  # noqa
SQLObject-3.1.0/docs/html/sqlobject/manager/0000755000175000017500000000000012754657361020165 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/manager/__init__.py.html0000644000175000017500000000471110223355362023225 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/manager/__init__.py
0001#
0002
SQLObject-3.1.0/docs/html/sqlobject/main.py.html0000644000175000017500000201151312752476767021026 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/main.py
0001"""
0002SQLObject
0003---------
0004
0005:author: Ian Bicking <ianb@colorstudy.com>
0006
0007SQLObject is a object-relational mapper.  See SQLObject.html or
0008SQLObject.rst for more.
0009
0010With the help by Oleg Broytman and many other contributors.
0011See Authors.rst.
0012
0013This program is free software; you can redistribute it and/or modify
0014it under the terms of the GNU Lesser General Public License as
0015published by the Free Software Foundation; either version 2.1 of the
0016License, or (at your option) any later version.
0017
0018This program is distributed in the hope that it will be useful,
0019but WITHOUT ANY WARRANTY; without even the implied warranty of
0020MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0021GNU General Public License for more details.
0022
0023You should have received a copy of the GNU Lesser General Public
0024License along with this program; if not, write to the Free Software
0025Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301,
0026USA.
0027"""
0028import sys
0029import threading
0030import weakref
0031import types
0032import warnings
0033from . import sqlbuilder
0034from . import dbconnection
0035from . import col
0036from . import styles
0037from . import joins
0038from . import index
0039from . import classregistry
0040from . import declarative
0041from . import events
0042from .sresults import SelectResults
0043from .util.threadinglocal import local
0044from sqlobject.compat import PY2, with_metaclass, string_type, unicode_type
0045
0046if ((sys.version_info[0] == 2) and (sys.version_info[:2] < (2, 6))) or      ((sys.version_info[0] == 3) and (sys.version_info[:2] < (3, 4))):
0048    raise ImportError("SQLObject requires Python 2.6, 2.7 or 3.4+")
0049
0050if not PY2:
0051    # alias for python 3 compatability
0052    long = int
0053
0054"""
0055This thread-local storage is needed for RowCreatedSignals. It gathers
0056code-blocks to execute _after_ the whole hierachy of inherited SQLObjects
0057is created. See SQLObject._create
0058"""
0059
0060NoDefault = sqlbuilder.NoDefault
0061
0062
0063class SQLObjectNotFound(LookupError):
0064    pass
0065
0066
0067class SQLObjectIntegrityError(Exception):
0068    pass
0069
0070
0071def makeProperties(obj):
0072    """
0073    This function takes a dictionary of methods and finds
0074    methods named like:
0075    * _get_attr
0076    * _set_attr
0077    * _del_attr
0078    * _doc_attr
0079    Except for _doc_attr, these should be methods.  It
0080    then creates properties from these methods, like
0081    property(_get_attr, _set_attr, _del_attr, _doc_attr).
0082    Missing methods are okay.
0083    """
0084
0085    if isinstance(obj, dict):
0086        def setFunc(var, value):
0087            obj[var] = value
0088        d = obj
0089    else:
0090        def setFunc(var, value):
0091            setattr(obj, var, value)
0092        d = obj.__dict__
0093
0094    props = {}
0095    for var, value in d.items():
0096        if var.startswith('_set_'):
0097            props.setdefault(var[5:], {})['set'] = value
0098        elif var.startswith('_get_'):
0099            props.setdefault(var[5:], {})['get'] = value
0100        elif var.startswith('_del_'):
0101            props.setdefault(var[5:], {})['del'] = value
0102        elif var.startswith('_doc_'):
0103            props.setdefault(var[5:], {})['doc'] = value
0104    for var, setters in props.items():
0105        if len(setters) == 1 and 'doc' in setters:
0106            continue
0107        if var in d:
0108            if isinstance(d[var], (types.MethodType, types.FunctionType)):
0109                warnings.warn(
0110                    "I tried to set the property %r, but it was "
0111                    "already set, as a method (%r).  Methods have "
0112                    "significantly different semantics than properties, "
0113                    "and this may be a sign of a bug in your code."
0114                    % (var, d[var]))
0115            continue
0116        setFunc(var,
0117                property(setters.get('get'), setters.get('set'),
0118                         setters.get('del'), setters.get('doc')))
0119
0120
0121def unmakeProperties(obj):
0122    if isinstance(obj, dict):
0123        def delFunc(obj, var):
0124            del obj[var]
0125        d = obj
0126    else:
0127        delFunc = delattr
0128        d = obj.__dict__
0129
0130    for var, value in list(d.items()):
0131        if isinstance(value, property):
0132            for prop in [value.fget, value.fset, value.fdel]:
0133                if prop and prop.__name__ not in d:
0134                    delFunc(obj, var)
0135                    break
0136
0137
0138def findDependencies(name, registry=None):
0139    depends = []
0140    for klass in classregistry.registry(registry).allClasses():
0141        if findDependantColumns(name, klass):
0142            depends.append(klass)
0143        else:
0144            for join in klass.sqlmeta.joins:
0145                if isinstance(join, joins.SORelatedJoin) and                           join.otherClassName == name:
0147                    depends.append(klass)
0148                    break
0149    return depends
0150
0151
0152def findDependantColumns(name, klass):
0153    depends = []
0154    for _col in klass.sqlmeta.columnList:
0155        if _col.foreignKey == name and _col.cascade is not None:
0156            depends.append(_col)
0157    return depends
0158
0159
0160def _collectAttributes(cls, new_attrs, look_for_class):
0161    """Finds all attributes in `new_attrs` that are instances of
0162    `look_for_class`. The ``.name`` attribute is set for any matching objects.
0163    Returns them as a list.
0164
0165    """
0166    result = []
0167    for attr, value in new_attrs.items():
0168        if isinstance(value, look_for_class):
0169            value.name = attr
0170            delattr(cls, attr)
0171            result.append(value)
0172    return result
0173
0174
0175class CreateNewSQLObject:
0176    """
0177    Dummy singleton to use in place of an ID, to signal we want
0178    a new object.
0179    """
0180    pass
0181
0182
0183class sqlmeta(with_metaclass(declarative.DeclarativeMeta, object)):
0184    """
0185    This object is the object we use to keep track of all sorts of
0186    information.  Subclasses are made for each SQLObject subclass
0187    (dynamically if necessary), and instances are created to go
0188    alongside every SQLObject instance.
0189    """
0190
0191    table = None
0192    idName = None
0193    idSequence = None
0194    # This function is used to coerce IDs into the proper format,
0195    # so you should replace it with str, or another function, if you
0196    # aren't using integer IDs
0197    idType = int
0198    style = None
0199    lazyUpdate = False
0200    defaultOrder = None
0201    cacheValues = True
0202    registry = None
0203    fromDatabase = False
0204    # Default is false, but we set it to true for the *instance*
0205    # when necessary: (bad clever? maybe)
0206    expired = False
0207
0208    # This is a mapping from column names to SOCol (or subclass)
0209    # instances:
0210    columns = {}
0211    columnList = []
0212
0213    # This is a mapping from column names to Col (or subclass)
0214    # instances; these objects don't have the logic that the SOCol
0215    # objects do, and are not attached to this class closely.
0216    columnDefinitions = {}
0217
0218    # These are lists of the join and index objects:
0219    indexes = []
0220    indexDefinitions = []
0221    joins = []
0222    joinDefinitions = []
0223
0224    # These attributes shouldn't be shared with superclasses:
0225    _unshared_attributes = ['table', 'columns', 'childName']
0226
0227    # These are internal bookkeeping attributes; the class-level
0228    # definition is a default for the instances, instances will
0229    # reset these values.
0230
0231    # When an object is being created, it has an instance
0232    # variable _creating, which is true.  This way all the
0233    # setters can be captured until the object is complete,
0234    # and then the row is inserted into the database.  Once
0235    # that happens, _creating is deleted from the instance,
0236    # and only the class variable (which is always false) is
0237    # left.
0238    _creating = False
0239    _obsolete = False
0240    # Sometimes an intance is attached to a connection, not
0241    # globally available.  In that case, self.sqlmeta._perConnection
0242    # will be true.  It's false by default:
0243    _perConnection = False
0244
0245    # Inheritance definitions:
0246    parentClass = None  # A reference to the parent class
0247    childClasses = {}  # References to child classes, keyed by childName
0248    childName = None  # Class name for inheritance child object creation
0249
0250    # Does the row require syncing?
0251    dirty = False
0252
0253    # Default encoding for UnicodeCol's
0254    dbEncoding = None
0255
0256    def __classinit__(cls, new_attrs):
0257        for attr in cls._unshared_attributes:
0258            if attr not in new_attrs:
0259                setattr(cls, attr, None)
0260        declarative.setup_attributes(cls, new_attrs)
0261
0262    def __init__(self, instance):
0263        self.instance = weakref.proxy(instance)
0264
0265    @classmethod
0266    def send(cls, signal, *args, **kw):
0267        events.send(signal, cls.soClass, *args, **kw)
0268
0269    @classmethod
0270    def setClass(cls, soClass):
0271        cls.soClass = soClass
0272        if not cls.style:
0273            cls.style = styles.defaultStyle
0274            try:
0275                if cls.soClass._connection and cls.soClass._connection.style:
0276                    cls.style = cls.soClass._connection.style
0277            except AttributeError:
0278                pass
0279        if cls.table is None:
0280            cls.table = cls.style.pythonClassToDBTable(cls.soClass.__name__)
0281        if cls.idName is None:
0282            cls.idName = cls.style.idForTable(cls.table)
0283
0284        # plainSetters are columns that haven't been overridden by the
0285        # user, so we can contact the database directly to set them.
0286        # Note that these can't set these in the SQLObject class
0287        # itself, because they specific to this subclass of SQLObject,
0288        # and cannot be shared among classes.
0289        cls._plainSetters = {}
0290        cls._plainGetters = {}
0291        cls._plainForeignSetters = {}
0292        cls._plainForeignGetters = {}
0293        cls._plainJoinGetters = {}
0294        cls._plainJoinAdders = {}
0295        cls._plainJoinRemovers = {}
0296
0297        # This is a dictionary of columnName: columnObject
0298        # None of these objects can be shared with superclasses
0299        cls.columns = {}
0300        cls.columnList = []
0301        # These, however, can be shared:
0302        cls.columnDefinitions = cls.columnDefinitions.copy()
0303        cls.indexes = []
0304        cls.indexDefinitions = cls.indexDefinitions[:]
0305        cls.joins = []
0306        cls.joinDefinitions = cls.joinDefinitions[:]
0307
0308    ############################################################
0309    # Adding special values, like columns and indexes
0310    ############################################################
0311
0312    ########################################
0313    # Column handling
0314    ########################################
0315
0316    @classmethod
0317    def addColumn(cls, columnDef, changeSchema=False, connection=None):
0318        post_funcs = []
0319        cls.send(events.AddColumnSignal, cls.soClass, connection,
0320                 columnDef.name, columnDef, changeSchema, post_funcs)
0321        sqlmeta = cls
0322        soClass = cls.soClass
0323        del cls
0324        column = columnDef.withClass(soClass)
0325        name = column.name
0326        assert name != 'id', (
0327            "The 'id' column is implicit, and should not be defined as "
0328            "a column")
0329        assert name not in sqlmeta.columns, (
0330            "The class %s.%s already has a column %r (%r), you cannot "
0331            "add the column %r"
0332            % (soClass.__module__, soClass.__name__, name,
0333               sqlmeta.columnDefinitions[name], columnDef))
0334        # Collect columns from the parent classes to test
0335        # if the column is not in a parent class
0336        parent_columns = []
0337        for base in soClass.__bases__:
0338            if hasattr(base, "sqlmeta"):
0339                parent_columns.extend(base.sqlmeta.columns.keys())
0340        if hasattr(soClass, name):
0341            assert (name in parent_columns) or (name == "childName"), (
0342                "The class %s.%s already has a variable or method %r, "
0343                "you cannot add the column %r" % (
0344                    soClass.__module__, soClass.__name__, name, name))
0345        sqlmeta.columnDefinitions[name] = columnDef
0346        sqlmeta.columns[name] = column
0347        # A stable-ordered version of the list...
0348        sqlmeta.columnList.append(column)
0349
0350        ###################################################
0351        # Create the getter function(s).  We'll start by
0352        # creating functions like _SO_get_columnName,
0353        # then if there's no function named _get_columnName
0354        # we'll alias that to _SO_get_columnName.  This
0355        # allows a sort of super call, even though there's
0356        # no superclass that defines the database access.
0357        if sqlmeta.cacheValues:
0358            # We create a method here, which is just a function
0359            # that takes "self" as the first argument.
0360            getter = eval(
0361                'lambda self: self._SO_loadValue(%s)' %
0362                repr(instanceName(name)))
0363
0364        else:
0365            # If we aren't caching values, we just call the
0366            # function _SO_getValue, which fetches from the
0367            # database.
0368            getter = eval('lambda self: self._SO_getValue(%s)' % repr(name))
0369        setattr(soClass, rawGetterName(name), getter)
0370
0371        # Here if the _get_columnName method isn't in the
0372        # definition, we add it with the default
0373        # _SO_get_columnName definition.
0374        if not hasattr(soClass, getterName(name)) or (name == 'childName'):
0375            setattr(soClass, getterName(name), getter)
0376            sqlmeta._plainGetters[name] = 1
0377
0378        #################################################
0379        # Create the setter function(s)
0380        # Much like creating the getters, we will create
0381        # _SO_set_columnName methods, and then alias them
0382        # to _set_columnName if the user hasn't defined
0383        # those methods themself.
0384
0385        # @@: This is lame; immutable right now makes it unsettable,
0386        # making the table read-only
0387        if not column.immutable:
0388            # We start by just using the _SO_setValue method
0389            setter = eval(
0390                'lambda self, val: self._SO_setValue'
0391                '(%s, val, self.%s, self.%s)' % (
0392                    repr(name),
0393                    '_SO_from_python_%s' % name, '_SO_to_python_%s' % name))
0394            setattr(soClass, '_SO_from_python_%s' % name, column.from_python)
0395            setattr(soClass, '_SO_to_python_%s' % name, column.to_python)
0396            setattr(soClass, rawSetterName(name), setter)
0397            # Then do the aliasing
0398            if not hasattr(soClass, setterName(name)) or (name == 'childName'):
0399                setattr(soClass, setterName(name), setter)
0400                # We keep track of setters that haven't been
0401                # overridden, because we can combine these
0402                # set columns into one SQL UPDATE query.
0403                sqlmeta._plainSetters[name] = 1
0404
0405        ##################################################
0406        # Here we check if the column is a foreign key, in
0407        # which case we need to make another method that
0408        # fetches the key and constructs the sister
0409        # SQLObject instance.
0410        if column.foreignKey:
0411
0412            # We go through the standard _SO_get_columnName deal
0413            # we're giving the object, not the ID of the
0414            # object this time:
0415            origName = column.origName
0416            if sqlmeta.cacheValues:
0417                # self._SO_class_className is a reference
0418                # to the class in question.
0419                getter = eval(
0420                    'lambda self: self._SO_foreignKey'
0421                    '(self._SO_loadValue(%r), self._SO_class_%s, %s)' %
0422                    (instanceName(name), column.foreignKey,
0423                     column.refColumn and repr(column.refColumn)))
0424            else:
0425                # Same non-caching version as above.
0426                getter = eval(
0427                    'lambda self: self._SO_foreignKey'
0428                    '(self._SO_getValue(%s), self._SO_class_%s, %s)' %
0429                    (repr(name), column.foreignKey,
0430                     column.refColumn and repr(column.refColumn)))
0431            setattr(soClass, rawGetterName(origName), getter)
0432
0433            # And we set the _get_columnName version
0434            if not hasattr(soClass, getterName(origName)):
0435                setattr(soClass, getterName(origName), getter)
0436                sqlmeta._plainForeignGetters[origName] = 1
0437
0438            if not column.immutable:
0439                # The setter just gets the ID of the object,
0440                # and then sets the real column.
0441                setter = eval(
0442                    'lambda self, val: '
0443                    'setattr(self, %s, self._SO_getID(val, %s))' %
0444                    (repr(name), column.refColumn and repr(column.refColumn)))
0445                setattr(soClass, rawSetterName(origName), setter)
0446                if not hasattr(soClass, setterName(origName)):
0447                    setattr(soClass, setterName(origName), setter)
0448                    sqlmeta._plainForeignSetters[origName] = 1
0449
0450            classregistry.registry(sqlmeta.registry).addClassCallback(
0451                column.foreignKey,
0452                lambda foreign, me, attr: setattr(me, attr, foreign),
0453                soClass, '_SO_class_%s' % column.foreignKey)
0454
0455        if column.alternateMethodName:
0456            func = eval(
0457                'lambda cls, val, connection=None: '
0458                'cls._SO_fetchAlternateID(%s, %s, val, connection=connection)'
0459                % (repr(column.name), repr(column.dbName)))
0460            setattr(soClass, column.alternateMethodName, classmethod(func))
0461
0462        if changeSchema:
0463            conn = connection or soClass._connection
0464            conn.addColumn(sqlmeta.table, column)
0465
0466        if soClass._SO_finishedClassCreation:
0467            makeProperties(soClass)
0468
0469        for func in post_funcs:
0470            func(soClass, column)
0471
0472    @classmethod
0473    def addColumnsFromDatabase(sqlmeta, connection=None):
0474        soClass = sqlmeta.soClass
0475        conn = connection or soClass._connection
0476        for columnDef in conn.columnsFromSchema(sqlmeta.table, soClass):
0477            if columnDef.name not in sqlmeta.columnDefinitions:
0478                if isinstance(columnDef.name, unicode_type) and PY2:
0479                    columnDef.name = columnDef.name.encode('ascii')
0480                sqlmeta.addColumn(columnDef)
0481
0482    @classmethod
0483    def delColumn(cls, column, changeSchema=False, connection=None):
0484        sqlmeta = cls
0485        soClass = sqlmeta.soClass
0486        if isinstance(column, str):
0487            if column in sqlmeta.columns:
0488                column = sqlmeta.columns[column]
0489            elif column + 'ID' in sqlmeta.columns:
0490                column = sqlmeta.columns[column + 'ID']
0491            else:
0492                raise ValueError('Unknown column ' + column)
0493        if isinstance(column, col.Col):
0494            for c in sqlmeta.columns.values():
0495                if column is c.columnDef:
0496                    column = c
0497                    break
0498            else:
0499                raise IndexError(
0500                    "Column with definition %r not found" % column)
0501        post_funcs = []
0502        cls.send(events.DeleteColumnSignal, cls.soClass, connection,
0503                 column.name, column, post_funcs)
0504        name = column.name
0505        del sqlmeta.columns[name]
0506        del sqlmeta.columnDefinitions[name]
0507        sqlmeta.columnList.remove(column)
0508        delattr(soClass, rawGetterName(name))
0509        if name in sqlmeta._plainGetters:
0510            delattr(soClass, getterName(name))
0511        delattr(soClass, rawSetterName(name))
0512        if name in sqlmeta._plainSetters:
0513            delattr(soClass, setterName(name))
0514        if column.foreignKey:
0515            delattr(soClass,
0516                    rawGetterName(soClass.sqlmeta.style.
0517                                  instanceIDAttrToAttr(name)))
0518            if name in sqlmeta._plainForeignGetters:
0519                delattr(soClass, getterName(name))
0520            delattr(soClass,
0521                    rawSetterName(soClass.sqlmeta.style.
0522                                  instanceIDAttrToAttr(name)))
0523            if name in sqlmeta._plainForeignSetters:
0524                delattr(soClass, setterName(name))
0525        if column.alternateMethodName:
0526            delattr(soClass, column.alternateMethodName)
0527
0528        if changeSchema:
0529            conn = connection or soClass._connection
0530            conn.delColumn(sqlmeta, column)
0531
0532        if soClass._SO_finishedClassCreation:
0533            unmakeProperties(soClass)
0534            makeProperties(soClass)
0535
0536        for func in post_funcs:
0537            func(soClass, column)
0538
0539    ########################################
0540    # Join handling
0541    ########################################
0542
0543    @classmethod
0544    def addJoin(cls, joinDef):
0545        sqlmeta = cls
0546        soClass = cls.soClass
0547        # The name of the method we'll create.  If it's
0548        # automatically generated, it's generated by the
0549        # join class.
0550        join = joinDef.withClass(soClass)
0551        meth = join.joinMethodName
0552
0553        sqlmeta.joins.append(join)
0554        index = len(sqlmeta.joins) - 1
0555        if joinDef not in sqlmeta.joinDefinitions:
0556            sqlmeta.joinDefinitions.append(joinDef)
0557
0558        # The function fetches the join by index, and
0559        # then lets the join object do the rest of the
0560        # work:
0561        func = eval(
0562            'lambda self: self.sqlmeta.joins[%i].performJoin(self)' % index)
0563
0564        # And we do the standard _SO_get_... _get_... deal
0565        setattr(soClass, rawGetterName(meth), func)
0566        if not hasattr(soClass, getterName(meth)):
0567            setattr(soClass, getterName(meth), func)
0568            sqlmeta._plainJoinGetters[meth] = 1
0569
0570        # Some joins allow you to remove objects from the
0571        # join.
0572        if hasattr(join, 'remove'):
0573            # Again, we let it do the remove, and we do the
0574            # standard naming trick.
0575            func = eval(
0576                'lambda self, obj: self.sqlmeta.joins[%i].remove(self, obj)' %
0577                index)
0578            setattr(soClass, '_SO_remove' + join.addRemoveName, func)
0579            if not hasattr(soClass, 'remove' + join.addRemoveName):
0580                setattr(soClass, 'remove' + join.addRemoveName, func)
0581                sqlmeta._plainJoinRemovers[meth] = 1
0582
0583        # Some joins allow you to add objects.
0584        if hasattr(join, 'add'):
0585            # And again...
0586            func = eval(
0587                'lambda self, obj: self.sqlmeta.joins[%i].add(self, obj)' %
0588                index)
0589            setattr(soClass, '_SO_add' + join.addRemoveName, func)
0590            if not hasattr(soClass, 'add' + join.addRemoveName):
0591                setattr(soClass, 'add' + join.addRemoveName, func)
0592                sqlmeta._plainJoinAdders[meth] = 1
0593
0594        if soClass._SO_finishedClassCreation:
0595            makeProperties(soClass)
0596
0597    @classmethod
0598    def delJoin(sqlmeta, joinDef):
0599        soClass = sqlmeta.soClass
0600        for join in sqlmeta.joins:
0601            # previously deleted joins will be None, so it must
0602            # be skipped or it'll error out on the next line.
0603            if join is None:
0604                continue
0605            if joinDef is join.joinDef:
0606                break
0607        else:
0608            raise IndexError(
0609                "Join %r not found in class %r (from %r)"
0610                % (joinDef, soClass, sqlmeta.joins))
0611        meth = join.joinMethodName
0612        sqlmeta.joinDefinitions.remove(joinDef)
0613        for i in range(len(sqlmeta.joins)):
0614            if sqlmeta.joins[i] is join:
0615                # Have to leave None, because we refer to joins
0616                # by index.
0617                sqlmeta.joins[i] = None
0618        delattr(soClass, rawGetterName(meth))
0619        if meth in sqlmeta._plainJoinGetters:
0620            delattr(soClass, getterName(meth))
0621        if hasattr(join, 'remove'):
0622            delattr(soClass, '_SO_remove' + join.addRemovePrefix)
0623            if meth in sqlmeta._plainJoinRemovers:
0624                delattr(soClass, 'remove' + join.addRemovePrefix)
0625        if hasattr(join, 'add'):
0626            delattr(soClass, '_SO_add' + join.addRemovePrefix)
0627            if meth in sqlmeta._plainJoinAdders:
0628                delattr(soClass, 'add' + join.addRemovePrefix)
0629
0630        if soClass._SO_finishedClassCreation:
0631            unmakeProperties(soClass)
0632            makeProperties(soClass)
0633
0634    ########################################
0635    # Indexes
0636    ########################################
0637
0638    @classmethod
0639    def addIndex(cls, indexDef):
0640        cls.indexDefinitions.append(indexDef)
0641        index = indexDef.withClass(cls.soClass)
0642        cls.indexes.append(index)
0643        setattr(cls.soClass, index.name, index)
0644
0645    ########################################
0646    # Utility methods
0647    ########################################
0648
0649    @classmethod
0650    def getColumns(sqlmeta):
0651        return sqlmeta.columns.copy()
0652
0653    def asDict(self):
0654        """
0655        Return the object as a dictionary of columns to values.
0656        """
0657        result = {}
0658        for key in self.getColumns():
0659            result[key] = getattr(self.instance, key)
0660        result['id'] = self.instance.id
0661        return result
0662
0663    @classmethod
0664    def expireAll(sqlmeta, connection=None):
0665        """
0666        Expire all instances of this class.
0667        """
0668        soClass = sqlmeta.soClass
0669        connection = connection or soClass._connection
0670        cache_set = connection.cache
0671        cache_set.weakrefAll(soClass)
0672        for item in cache_set.getAll(soClass):
0673            item.expire()
0674
0675
0676sqlhub = dbconnection.ConnectionHub()
0677
0678
0679# Turning it on gives earlier warning about things
0680# that will be deprecated (having this off we won't flood people
0681# with warnings right away).
0682warnings_level = 1
0683exception_level = None
0684# Current levels:
0685#  1) Actively deprecated
0686#  2) Deprecated after 1
0687#  3) Deprecated after 2
0688
0689
0690def deprecated(message, level=1, stacklevel=2):
0691    if exception_level is not None and exception_level <= level:
0692        raise NotImplementedError(message)
0693    if warnings_level is not None and warnings_level <= level:
0694        warnings.warn(message, DeprecationWarning, stacklevel=stacklevel)
0695
0696# if sys.version_info[:2] < (2, 6):
0697#     deprecated("Support for Python 2.5 has been declared obsolete "
0698#     "and will be removed in the next release of SQLObject")
0699
0700
0701def setDeprecationLevel(warning=1, exception=None):
0702    """
0703    Set the deprecation level for SQLObject.  Low levels are more
0704    actively being deprecated.  Any warning at a level at or below
0705    ``warning`` will give a warning.  Any warning at a level at or
0706    below ``exception`` will give an exception.  You can use a higher
0707    ``exception`` level for tests to help upgrade your code.  ``None``
0708    for either value means never warn or raise exceptions.
0709
0710    The levels currently mean:
0711
0712      1) Deprecated in current version.  Will be removed in next version.
0713
0714      2) Planned to deprecate in next version, remove later.
0715
0716      3) Planned to deprecate sometime, remove sometime much later.
0717
0718    As the SQLObject versions progress, the deprecation level of
0719    specific features will go down, indicating the advancing nature of
0720    the feature's doom.  We'll try to keep features at 1 for a major
0721    revision.
0722
0723    As time continues there may be a level 0, which will give a useful
0724    error message (better than ``AttributeError``) but where the
0725    feature has been fully removed.
0726    """
0727    global warnings_level, exception_level
0728    warnings_level = warning
0729    exception_level = exception
0730
0731
0732class _sqlmeta_attr(object):
0733
0734    def __init__(self, name, deprecation_level):
0735        self.name = name
0736        self.deprecation_level = deprecation_level
0737
0738    def __get__(self, obj, type=None):
0739        if self.deprecation_level is not None:
0740            deprecated(
0741                'Use of this attribute should be replaced with '
0742                '.sqlmeta.%s' % self.name, level=self.deprecation_level)
0743        return getattr((type or obj).sqlmeta, self.name)
0744
0745
0746_postponed_local = local()
0747
0748
0749# SQLObject is the superclass for all SQLObject classes, of
0750# course.  All the deeper magic is done in MetaSQLObject, and
0751# only lesser magic is done here.  All the actual work is done
0752# here, though -- just automatic method generation (like
0753# methods and properties for each column) is done in
0754# MetaSQLObject.
0755
0756
0757class SQLObject(with_metaclass(declarative.DeclarativeMeta, object)):
0758
0759    _connection = sqlhub
0760
0761    sqlmeta = sqlmeta
0762
0763    # DSM: The _inheritable attribute controls wheter the class can by
0764    # DSM: inherited 'logically' with a foreignKey and a back reference.
0765    _inheritable = False  # Is this class inheritable?
0766    _parent = None  # A reference to the parent instance
0767    childName = None  # Children name (to be able to get a subclass)
0768
0769    # The law of Demeter: the class should not call another classes by name
0770    SelectResultsClass = SelectResults
0771
0772    def __classinit__(cls, new_attrs):
0773
0774        # This is true if we're initializing the SQLObject class,
0775        # instead of a subclass:
0776        is_base = cls.__bases__ == (object,)
0777
0778        cls._SO_setupSqlmeta(new_attrs, is_base)
0779
0780        implicitColumns = _collectAttributes(cls, new_attrs, col.Col)
0781        implicitJoins = _collectAttributes(cls, new_attrs, joins.Join)
0782        implicitIndexes = _collectAttributes(cls, new_attrs,
0783                                             index.DatabaseIndex)
0784
0785        if not is_base:
0786            cls._SO_cleanDeprecatedAttrs(new_attrs)
0787
0788        if '_connection' in new_attrs:
0789            connection = new_attrs['_connection']
0790            del cls._connection
0791            assert 'connection' not in new_attrs
0792        elif 'connection' in new_attrs:
0793            connection = new_attrs['connection']
0794            del cls.connection
0795        else:
0796            connection = None
0797
0798        cls._SO_finishedClassCreation = False
0799
0800        ######################################################
0801        # Set some attributes to their defaults, if necessary.
0802        # First we get the connection:
0803        if not connection and not getattr(cls, '_connection', None):
0804            mod = sys.modules[cls.__module__]
0805            # See if there's a __connection__ global in
0806            # the module, use it if there is.
0807            if hasattr(mod, '__connection__'):
0808                connection = mod.__connection__
0809
0810        # Do not check hasattr(cls, '_connection') here - it is possible
0811        # SQLObject parent class has a connection attribute that came
0812        # from sqlhub, e.g.; check __dict__ only.
0813        if connection and ('_connection' not in cls.__dict__):
0814            cls.setConnection(connection)
0815
0816        sqlmeta = cls.sqlmeta
0817
0818        # We have to check if there are columns in the inherited
0819        # _columns where the attribute has been set to None in this
0820        # class.  If so, then we need to remove that column from
0821        # _columns.
0822        for key in sqlmeta.columnDefinitions.keys():
0823            if (key in new_attrs and new_attrs[key] is None):
0824                del sqlmeta.columnDefinitions[key]
0825
0826        for column in sqlmeta.columnDefinitions.values():
0827            sqlmeta.addColumn(column)
0828
0829        for column in implicitColumns:
0830            sqlmeta.addColumn(column)
0831
0832        # Now the class is in an essentially OK-state, so we can
0833        # set up any magic attributes:
0834        declarative.setup_attributes(cls, new_attrs)
0835
0836        if sqlmeta.fromDatabase:
0837            sqlmeta.addColumnsFromDatabase()
0838
0839        for j in implicitJoins:
0840            sqlmeta.addJoin(j)
0841        for i in implicitIndexes:
0842            sqlmeta.addIndex(i)
0843
0844        def order_getter(o):
0845            return o.creationOrder
0846        sqlmeta.columnList.sort(key=order_getter)
0847        sqlmeta.indexes.sort(key=order_getter)
0848        sqlmeta.indexDefinitions.sort(key=order_getter)
0849        # Joins cannot be sorted because addJoin created accessors
0850        # that remember indexes.
0851        # sqlmeta.joins.sort(key=order_getter)
0852        sqlmeta.joinDefinitions.sort(key=order_getter)
0853
0854        # We don't setup the properties until we're finished with the
0855        # batch adding of all the columns...
0856        cls._notifyFinishClassCreation()
0857        cls._SO_finishedClassCreation = True
0858        makeProperties(cls)
0859
0860        # We use the magic "q" attribute for accessing lazy
0861        # SQL where-clause generation.  See the sql module for
0862        # more.
0863        if not is_base:
0864            cls.q = sqlbuilder.SQLObjectTable(cls)
0865            cls.j = sqlbuilder.SQLObjectTableWithJoins(cls)
0866
0867        classregistry.registry(sqlmeta.registry).addClass(cls)
0868
0869    @classmethod
0870    def _SO_setupSqlmeta(cls, new_attrs, is_base):
0871        """
0872        This fixes up the sqlmeta attribute.  It handles both the case
0873        where no sqlmeta was given (in which we need to create another
0874        subclass), or the sqlmeta given doesn't have the proper
0875        inheritance.  Lastly it calls sqlmeta.setClass, which handles
0876        much of the setup.
0877        """
0878        if ('sqlmeta' not in new_attrs and not is_base):
0879            # We have to create our own subclass, usually.
0880            # type(className, bases_tuple, attr_dict) creates a new subclass.
0881            cls.sqlmeta = type('sqlmeta', (cls.sqlmeta,), {})
0882        if not issubclass(cls.sqlmeta, sqlmeta):
0883            # We allow no superclass and an object superclass, instead
0884            # of inheriting from sqlmeta; but in that case we replace
0885            # the class and just move over its attributes:
0886            assert cls.sqlmeta.__bases__ in ((), (object,)), (
0887                "If you do not inherit your sqlmeta class from "
0888                "sqlobject.sqlmeta, it must not inherit from any other "
0889                "class (your sqlmeta inherits from: %s)"
0890                % cls.sqlmeta.__bases__)
0891            for base in cls.__bases__:
0892                superclass = getattr(base, 'sqlmeta', None)
0893                if superclass:
0894                    break
0895            else:
0896                assert 0, (
0897                    "No sqlmeta class could be found in any superclass "
0898                    "(while fixing up sqlmeta %r inheritance)"
0899                    % cls.sqlmeta)
0900            values = dict(cls.sqlmeta.__dict__)
0901            for key in list(values.keys()):
0902                if key.startswith('__') and key.endswith('__'):
0903                    # Magic values shouldn't be passed through:
0904                    del values[key]
0905            cls.sqlmeta = type('sqlmeta', (superclass,), values)
0906
0907        if not is_base:  # Do not pollute the base sqlmeta class
0908            cls.sqlmeta.setClass(cls)
0909
0910    @classmethod
0911    def _SO_cleanDeprecatedAttrs(cls, new_attrs):
0912        """
0913        This removes attributes on SQLObject subclasses that have
0914        been deprecated; they are moved to the sqlmeta class, and
0915        a deprecation warning is given.
0916        """
0917        for attr in ():
0918            if attr in new_attrs:
0919                deprecated("%r is deprecated and read-only; please do "
0920                           "not use it in your classes until it is fully "
0921                           "deprecated" % attr, level=1, stacklevel=5)
0922
0923    @classmethod
0924    def get(cls, id, connection=None, selectResults=None):
0925
0926        assert id is not None,               'None is not a possible id for %s' % cls.__name__
0928
0929        id = cls.sqlmeta.idType(id)
0930
0931        if connection is None:
0932            cache = cls._connection.cache
0933        else:
0934            cache = connection.cache
0935
0936        # This whole sequence comes from Cache.CacheFactory's
0937        # behavior, where a None returned means a cache miss.
0938        val = cache.get(id, cls)
0939        if val is None:
0940            try:
0941                val = cls(_SO_fetch_no_create=1)
0942                val._SO_validatorState = sqlbuilder.SQLObjectState(val)
0943                val._init(id, connection, selectResults)
0944                cache.put(id, cls, val)
0945            finally:
0946                cache.finishPut(cls)
0947        elif selectResults and not val.sqlmeta.dirty:
0948            val._SO_writeLock.acquire()
0949            try:
0950                val._SO_selectInit(selectResults)
0951                val.sqlmeta.expired = False
0952            finally:
0953                val._SO_writeLock.release()
0954        return val
0955
0956    @classmethod
0957    def _notifyFinishClassCreation(cls):
0958        pass
0959
0960    def _init(self, id, connection=None, selectResults=None):
0961        assert id is not None
0962        # This function gets called only when the object is
0963        # created, unlike __init__ which would be called
0964        # anytime the object was returned from cache.
0965        self.id = id
0966        self._SO_writeLock = threading.Lock()
0967
0968        # If no connection was given, we'll inherit the class
0969        # instance variable which should have a _connection
0970        # attribute.
0971        if (connection is not None) and                   (getattr(self, '_connection', None) is not connection):
0973            self._connection = connection
0974            # Sometimes we need to know if this instance is
0975            # global or tied to a particular connection.
0976            # This flag tells us that:
0977            self.sqlmeta._perConnection = True
0978
0979        if not selectResults:
0980            dbNames = [col.dbName for col in self.sqlmeta.columnList]
0981            selectResults = self._connection._SO_selectOne(self, dbNames)
0982            if not selectResults:
0983                raise SQLObjectNotFound(
0984                    "The object %s by the ID %s does not exist" % (
0985                        self.__class__.__name__, self.id))
0986        self._SO_selectInit(selectResults)
0987        self._SO_createValues = {}
0988        self.sqlmeta.dirty = False
0989
0990    def _SO_loadValue(self, attrName):
0991        try:
0992            return getattr(self, attrName)
0993        except AttributeError:
0994            try:
0995                self._SO_writeLock.acquire()
0996                try:
0997                    # Maybe, just in the moment since we got the lock,
0998                    # some other thread did a _SO_loadValue and we
0999                    # have the attribute!  Let's try and find out!  We
1000                    # can keep trying this all day and still beat the
1001                    # performance on the database call (okay, we can
1002                    # keep trying this for a few msecs at least)...
1003                    result = getattr(self, attrName)
1004                except AttributeError:
1005                    pass
1006                else:
1007                    return result
1008                self.sqlmeta.expired = False
1009                dbNames = [col.dbName for col in self.sqlmeta.columnList]
1010                selectResults = self._connection._SO_selectOne(self, dbNames)
1011                if not selectResults:
1012                    raise SQLObjectNotFound(
1013                        "The object %s by the ID %s has been deleted" % (
1014                            self.__class__.__name__, self.id))
1015                self._SO_selectInit(selectResults)
1016                result = getattr(self, attrName)
1017                return result
1018            finally:
1019                self._SO_writeLock.release()
1020
1021    def sync(self):
1022        if self.sqlmeta.lazyUpdate and self._SO_createValues:
1023            self.syncUpdate()
1024        self._SO_writeLock.acquire()
1025        try:
1026            dbNames = [col.dbName for col in self.sqlmeta.columnList]
1027            selectResults = self._connection._SO_selectOne(self, dbNames)
1028            if not selectResults:
1029                raise SQLObjectNotFound(
1030                    "The object %s by the ID %s has been deleted" % (
1031                        self.__class__.__name__, self.id))
1032            self._SO_selectInit(selectResults)
1033            self.sqlmeta.expired = False
1034        finally:
1035            self._SO_writeLock.release()
1036
1037    def syncUpdate(self):
1038        if not self._SO_createValues:
1039            return
1040        self._SO_writeLock.acquire()
1041        try:
1042            if self.sqlmeta.columns:
1043                columns = self.sqlmeta.columns
1044                values = [(columns[v[0]].dbName, v[1])
1045                          for v in sorted(
1046                              self._SO_createValues.items(),
1047                              key=lambda c: columns[c[0]].creationOrder)]
1048                self._connection._SO_update(self, values)
1049            self.sqlmeta.dirty = False
1050            self._SO_createValues = {}
1051        finally:
1052            self._SO_writeLock.release()
1053
1054        post_funcs = []
1055        self.sqlmeta.send(events.RowUpdatedSignal, self, post_funcs)
1056        for func in post_funcs:
1057            func(self)
1058
1059    def expire(self):
1060        if self.sqlmeta.expired:
1061            return
1062        self._SO_writeLock.acquire()
1063        try:
1064            if self.sqlmeta.expired:
1065                return
1066            for column in self.sqlmeta.columnList:
1067                delattr(self, instanceName(column.name))
1068            self.sqlmeta.expired = True
1069            self._connection.cache.expire(self.id, self.__class__)
1070            self._SO_createValues = {}
1071        finally:
1072            self._SO_writeLock.release()
1073
1074    def _SO_setValue(self, name, value, from_python, to_python):
1075        # This is the place where we actually update the
1076        # database.
1077
1078        # If we are _creating, the object doesn't yet exist
1079        # in the database, and we can't insert it until all
1080        # the parts are set.  So we just keep them in a
1081        # dictionary until later:
1082        d = {name: value}
1083        if not self.sqlmeta._creating and                   not getattr(self.sqlmeta, "row_update_sig_suppress", False):
1085            self.sqlmeta.send(events.RowUpdateSignal, self, d)
1086        if len(d) != 1 or name not in d:
1087            # Already called RowUpdateSignal, don't call it again
1088            # inside .set()
1089            self.sqlmeta.row_update_sig_suppress = True
1090            self.set(**d)
1091            del self.sqlmeta.row_update_sig_suppress
1092        value = d[name]
1093        if from_python:
1094            dbValue = from_python(value, self._SO_validatorState)
1095        else:
1096            dbValue = value
1097        if to_python:
1098            value = to_python(dbValue, self._SO_validatorState)
1099        if self.sqlmeta._creating or self.sqlmeta.lazyUpdate:
1100            self.sqlmeta.dirty = True
1101            self._SO_createValues[name] = dbValue
1102            setattr(self, instanceName(name), value)
1103            return
1104
1105        self._connection._SO_update(
1106            self, [(self.sqlmeta.columns[name].dbName,
1107                    dbValue)])
1108
1109        if self.sqlmeta.cacheValues:
1110            setattr(self, instanceName(name), value)
1111
1112        post_funcs = []
1113        self.sqlmeta.send(events.RowUpdatedSignal, self, post_funcs)
1114        for func in post_funcs:
1115            func(self)
1116
1117    def set(self, _suppress_set_sig=False, **kw):
1118        if not self.sqlmeta._creating and                   not getattr(self.sqlmeta, "row_update_sig_suppress", False)                   and not _suppress_set_sig:
1121            self.sqlmeta.send(events.RowUpdateSignal, self, kw)
1122        # set() is used to update multiple values at once,
1123        # potentially with one SQL statement if possible.
1124
1125        # Filter out items that don't map to column names.
1126        # Those will be set directly on the object using
1127        # setattr(obj, name, value).
1128        def is_column(_c):
1129            return _c in self.sqlmeta._plainSetters
1130
1131        def f_is_column(item):
1132            return is_column(item[0])
1133
1134        def f_not_column(item):
1135            return not is_column(item[0])
1136        items = kw.items()
1137        extra = dict(filter(f_not_column, items))
1138        kw = dict(filter(f_is_column, items))
1139
1140        # _creating is special, see _SO_setValue
1141        if self.sqlmeta._creating or self.sqlmeta.lazyUpdate:
1142            for name, value in kw.items():
1143                from_python = getattr(self, '_SO_from_python_%s' % name, None)
1144                if from_python:
1145                    kw[name] = dbValue = from_python(value,
1146                                                     self._SO_validatorState)
1147                else:
1148                    dbValue = value
1149                to_python = getattr(self, '_SO_to_python_%s' % name, None)
1150                if to_python:
1151                    value = to_python(dbValue, self._SO_validatorState)
1152                setattr(self, instanceName(name), value)
1153
1154            self._SO_createValues.update(kw)
1155
1156            for name, value in extra.items():
1157                try:
1158                    getattr(self.__class__, name)
1159                except AttributeError:
1160                    if name not in self.sqlmeta.columns:
1161                        raise TypeError(
1162                            "%s.set() got an unexpected keyword argument "
1163                            "%s" % (self.__class__.__name__, name))
1164                try:
1165                    setattr(self, name, value)
1166                except AttributeError as e:
1167                    raise AttributeError('%s (with attribute %r)' % (e, name))
1168
1169            self.sqlmeta.dirty = True
1170            return
1171
1172        self._SO_writeLock.acquire()
1173
1174        try:
1175            # We have to go through and see if the setters are
1176            # "plain", that is, if the user has changed their
1177            # definition in any way (put in something that
1178            # normalizes the value or checks for consistency,
1179            # for instance).  If so then we have to use plain
1180            # old setattr() to change the value, since we can't
1181            # read the user's mind.  We'll combine everything
1182            # else into a single UPDATE, if necessary.
1183            toUpdate = {}
1184            for name, value in kw.items():
1185                from_python = getattr(self, '_SO_from_python_%s' % name, None)
1186                if from_python:
1187                    dbValue = from_python(value, self._SO_validatorState)
1188                else:
1189                    dbValue = value
1190                to_python = getattr(self, '_SO_to_python_%s' % name, None)
1191                if to_python:
1192                    value = to_python(dbValue, self._SO_validatorState)
1193                if self.sqlmeta.cacheValues:
1194                    setattr(self, instanceName(name), value)
1195                toUpdate[name] = dbValue
1196            for name, value in extra.items():
1197                try:
1198                    getattr(self.__class__, name)
1199                except AttributeError:
1200                    if name not in self.sqlmeta.columns:
1201                        raise TypeError(
1202                            "%s.set() got an unexpected keyword argument "
1203                            "%s" % (self.__class__.__name__, name))
1204                try:
1205                    setattr(self, name, value)
1206                except AttributeError as e:
1207                    raise AttributeError('%s (with attribute %r)' % (e, name))
1208
1209            if toUpdate:
1210                toUpdate = sorted(
1211                    toUpdate.items(),
1212                    key=lambda c: self.sqlmeta.columns[c[0]].creationOrder)
1213                args = [(self.sqlmeta.columns[name].dbName, value)
1214                        for name, value in toUpdate]
1215                self._connection._SO_update(self, args)
1216        finally:
1217            self._SO_writeLock.release()
1218
1219        post_funcs = []
1220        self.sqlmeta.send(events.RowUpdatedSignal, self, post_funcs)
1221        for func in post_funcs:
1222            func(self)
1223
1224    def _SO_selectInit(self, row):
1225        for _col, colValue in zip(self.sqlmeta.columnList, row):
1226            if _col.to_python:
1227                colValue = _col.to_python(colValue, self._SO_validatorState)
1228            setattr(self, instanceName(_col.name), colValue)
1229
1230    def _SO_getValue(self, name):
1231        # Retrieves a single value from the database.  Simple.
1232        assert not self.sqlmeta._obsolete, (
1233            "%s with id %s has become obsolete"
1234            % (self.__class__.__name__, self.id))
1235        # @@: do we really need this lock?
1236        # self._SO_writeLock.acquire()
1237        column = self.sqlmeta.columns[name]
1238        results = self._connection._SO_selectOne(self, [column.dbName])
1239        # self._SO_writeLock.release()
1240        assert results is not None, "%s with id %s is not in the database" % (
1241            self.__class__.__name__, self.id)
1242        value = results[0]
1243        if column.to_python:
1244            value = column.to_python(value, self._SO_validatorState)
1245        return value
1246
1247    def _SO_foreignKey(self, value, joinClass, idName=None):
1248        if value is None:
1249            return None
1250        if self.sqlmeta._perConnection:
1251            connection = self._connection
1252        else:
1253            connection = None
1254        if idName is None:  # Get by id
1255            return joinClass.get(value, connection=connection)
1256        return joinClass.select(
1257            getattr(joinClass.q, idName) == value,
1258            connection=connection).getOne()
1259
1260    def __init__(self, **kw):
1261        # If we are the outmost constructor of a hiearchy of
1262        # InheritableSQLObjects (or simlpy _the_ constructor of a "normal"
1263        # SQLObject), we create a threadlocal list that collects the
1264        # RowCreatedSignals, and executes them if this very constructor is left
1265        try:
1266            _postponed_local.postponed_calls
1267            postponed_created = False
1268        except AttributeError:
1269            _postponed_local.postponed_calls = []
1270            postponed_created = True
1271
1272        try:
1273            # We shadow the sqlmeta class with an instance of sqlmeta
1274            # that points to us (our sqlmeta buddy object; where the
1275            # sqlmeta class is our class's buddy class)
1276            self.sqlmeta = self.__class__.sqlmeta(self)
1277            # The get() classmethod/constructor uses a magic keyword
1278            # argument when it wants an empty object, fetched from the
1279            # database.  So we have nothing more to do in that case:
1280            if '_SO_fetch_no_create' in kw:
1281                return
1282
1283            post_funcs = []
1284            self.sqlmeta.send(events.RowCreateSignal, self, kw, post_funcs)
1285
1286            # Pass the connection object along if we were given one.
1287            if 'connection' in kw:
1288                connection = kw.pop('connection')
1289                if getattr(self, '_connection', None) is not connection:
1290                    self._connection = connection
1291                    self.sqlmeta._perConnection = True
1292
1293            self._SO_writeLock = threading.Lock()
1294
1295            if 'id' in kw:
1296                id = self.sqlmeta.idType(kw['id'])
1297                del kw['id']
1298            else:
1299                id = None
1300
1301            self._create(id, **kw)
1302
1303            for func in post_funcs:
1304                func(self)
1305        finally:
1306            # if we are the creator of the tl-storage, we
1307            # have to exectute and under all circumstances
1308            # remove the tl-storage
1309            if postponed_created:
1310                try:
1311                    for func in _postponed_local.postponed_calls:
1312                        func()
1313                finally:
1314                    del _postponed_local.postponed_calls
1315
1316    def _create(self, id, **kw):
1317
1318        self.sqlmeta._creating = True
1319        self._SO_createValues = {}
1320        self._SO_validatorState = sqlbuilder.SQLObjectState(self)
1321
1322        # First we do a little fix-up on the keywords we were
1323        # passed:
1324        for column in self.sqlmeta.columnList:
1325
1326            # Then we check if the column wasn't passed in, and
1327            # if not we try to get the default.
1328            if column.name not in kw and column.foreignName not in kw:
1329                default = column.default
1330
1331                # If we don't get it, it's an error:
1332                # If we specified an SQL DEFAULT, then we should use that
1333                if default is NoDefault:
1334                    if column.defaultSQL is None:
1335                        raise TypeError(
1336                            "%s() did not get expected keyword argument "
1337                            "'%s'" % (self.__class__.__name__, column.name))
1338                    else:
1339                        # There is defaultSQL for the column -
1340                        # do not put the column to kw
1341                        # so that the backend creates the value.
1342                        continue
1343
1344                # Otherwise we put it in as though they did pass
1345                # that keyword:
1346
1347                kw[column.name] = default
1348
1349        self.set(**kw)
1350
1351        # Then we finalize the process:
1352        self._SO_finishCreate(id)
1353
1354    def _SO_finishCreate(self, id=None):
1355        # Here's where an INSERT is finalized.
1356        # These are all the column values that were supposed
1357        # to be set, but were delayed until now:
1358        setters = self._SO_createValues.items()
1359        setters = sorted(
1360            setters, key=lambda c: self.sqlmeta.columns[c[0]].creationOrder)
1361        # Here's their database names:
1362        names = [self.sqlmeta.columns[v[0]].dbName for v in setters]
1363        values = [v[1] for v in setters]
1364        # Get rid of _SO_create*, we aren't creating anymore.
1365        # Doesn't have to be threadsafe because we're still in
1366        # new(), which doesn't need to be threadsafe.
1367        self.sqlmeta.dirty = False
1368        if not self.sqlmeta.lazyUpdate:
1369            del self._SO_createValues
1370        else:
1371            self._SO_createValues = {}
1372        del self.sqlmeta._creating
1373
1374        # Do the insert -- most of the SQL in this case is left
1375        # up to DBConnection, since getting a new ID is
1376        # non-standard.
1377        id = self._connection.queryInsertID(self,
1378                                            id, names, values)
1379        cache = self._connection.cache
1380        cache.created(id, self.__class__, self)
1381        self._init(id)
1382        post_funcs = []
1383        kw = dict([('class', self.__class__), ('id', id)])
1384
1385        def _send_RowCreatedSignal():
1386            self.sqlmeta.send(events.RowCreatedSignal, self, kw, post_funcs)
1387            for func in post_funcs:
1388                func(self)
1389        _postponed_local.postponed_calls.append(_send_RowCreatedSignal)
1390
1391    def _SO_getID(self, obj, refColumn=None):
1392        return getID(obj, refColumn)
1393
1394    @classmethod
1395    def _findAlternateID(cls, name, dbName, value, connection=None):
1396        if isinstance(name, str):
1397            name = (name,)
1398            value = (value,)
1399        if len(name) != len(value):
1400            raise ValueError(
1401                "'column' and 'value' tuples must be of the same size")
1402        new_value = []
1403        for n, v in zip(name, value):
1404            from_python = getattr(cls, '_SO_from_python_' + n)
1405            if from_python:
1406                v = from_python(
1407                    v, sqlbuilder.SQLObjectState(cls, connection=connection))
1408            new_value.append(v)
1409        condition = sqlbuilder.AND(
1410            *[getattr(cls.q, _n) == _v for _n, _v in zip(name, new_value)])
1411        return (connection or cls._connection)._SO_selectOneAlt(
1412            cls,
1413            [cls.sqlmeta.idName] +
1414            [column.dbName for column in cls.sqlmeta.columnList],
1415            condition), None
1416
1417    @classmethod
1418    def _SO_fetchAlternateID(cls, name, dbName, value, connection=None,
1419                             idxName=None):
1420        result, obj = cls._findAlternateID(name, dbName, value, connection)
1421        if not result:
1422            if idxName is None:
1423                raise SQLObjectNotFound(
1424                    "The %s by alternateID %s = %s does not exist" % (
1425                        cls.__name__, name, repr(value)))
1426            else:
1427                names = []
1428                for i in range(len(name)):
1429                    names.append("%s = %s" % (name[i], repr(value[i])))
1430                names = ', '.join(names)
1431                raise SQLObjectNotFound(
1432                    "The %s by unique index %s(%s) does not exist" % (
1433                        cls.__name__, idxName, names))
1434        if obj:
1435            return obj
1436        if connection:
1437            obj = cls.get(result[0], connection=connection,
1438                          selectResults=result[1:])
1439        else:
1440            obj = cls.get(result[0], selectResults=result[1:])
1441        return obj
1442
1443    @classmethod
1444    def _SO_depends(cls):
1445        return findDependencies(cls.__name__, cls.sqlmeta.registry)
1446
1447    @classmethod
1448    def select(cls, clause=None, clauseTables=None,
1449               orderBy=NoDefault, limit=None,
1450               lazyColumns=False, reversed=False,
1451               distinct=False, connection=None,
1452               join=None, forUpdate=False):
1453        return cls.SelectResultsClass(cls, clause,
1454                                      clauseTables=clauseTables,
1455                                      orderBy=orderBy,
1456                                      limit=limit,
1457                                      lazyColumns=lazyColumns,
1458                                      reversed=reversed,
1459                                      distinct=distinct,
1460                                      connection=connection,
1461                                      join=join, forUpdate=forUpdate)
1462
1463    @classmethod
1464    def selectBy(cls, connection=None, **kw):
1465        conn = connection or cls._connection
1466        return cls.SelectResultsClass(cls,
1467                                      conn._SO_columnClause(cls, kw),
1468                                      connection=conn)
1469
1470    @classmethod
1471    def tableExists(cls, connection=None):
1472        conn = connection or cls._connection
1473        return conn.tableExists(cls.sqlmeta.table)
1474
1475    @classmethod
1476    def dropTable(cls, ifExists=False, dropJoinTables=True, cascade=False,
1477                  connection=None):
1478        conn = connection or cls._connection
1479        if ifExists and not cls.tableExists(connection=conn):
1480            return
1481        extra_sql = []
1482        post_funcs = []
1483        cls.sqlmeta.send(events.DropTableSignal, cls, connection,
1484                         extra_sql, post_funcs)
1485        conn.dropTable(cls.sqlmeta.table, cascade)
1486        if dropJoinTables:
1487            cls.dropJoinTables(ifExists=ifExists, connection=conn)
1488        for sql in extra_sql:
1489            connection.query(sql)
1490        for func in post_funcs:
1491            func(cls, conn)
1492
1493    @classmethod
1494    def createTable(cls, ifNotExists=False, createJoinTables=True,
1495                    createIndexes=True, applyConstraints=True,
1496                    connection=None):
1497        conn = connection or cls._connection
1498        if ifNotExists and cls.tableExists(connection=conn):
1499            return
1500        extra_sql = []
1501        post_funcs = []
1502        cls.sqlmeta.send(events.CreateTableSignal, cls, connection,
1503                         extra_sql, post_funcs)
1504        constraints = conn.createTable(cls)
1505        if applyConstraints:
1506            for constraint in constraints:
1507                conn.query(constraint)
1508        else:
1509            extra_sql.extend(constraints)
1510        if createJoinTables:
1511            cls.createJoinTables(ifNotExists=ifNotExists,
1512                                 connection=conn)
1513        if createIndexes:
1514            cls.createIndexes(ifNotExists=ifNotExists,
1515                              connection=conn)
1516        for func in post_funcs:
1517            func(cls, conn)
1518        return extra_sql
1519
1520    @classmethod
1521    def createTableSQL(cls, createJoinTables=True, createIndexes=True,
1522                       connection=None):
1523        conn = connection or cls._connection
1524        sql, constraints = conn.createTableSQL(cls)
1525        if createJoinTables:
1526            join_sql = cls.createJoinTablesSQL(connection=conn)
1527            if join_sql:
1528                sql += ';\n' + join_sql
1529        if createIndexes:
1530            index_sql = cls.createIndexesSQL(connection=conn)
1531            if index_sql:
1532                sql += ';\n' + index_sql
1533        return sql, constraints
1534
1535    @classmethod
1536    def createJoinTables(cls, ifNotExists=False, connection=None):
1537        conn = connection or cls._connection
1538        for join in cls._getJoinsToCreate():
1539            if (ifNotExists and
1540                    conn.tableExists(join.intermediateTable)):
1541                continue
1542            conn._SO_createJoinTable(join)
1543
1544    @classmethod
1545    def createJoinTablesSQL(cls, connection=None):
1546        conn = connection or cls._connection
1547        sql = []
1548        for join in cls._getJoinsToCreate():
1549            sql.append(conn._SO_createJoinTableSQL(join))
1550        return ';\n'.join(sql)
1551
1552    @classmethod
1553    def createIndexes(cls, ifNotExists=False, connection=None):
1554        conn = connection or cls._connection
1555        for _index in cls.sqlmeta.indexes:
1556            if not _index:
1557                continue
1558            conn._SO_createIndex(cls, _index)
1559
1560    @classmethod
1561    def createIndexesSQL(cls, connection=None):
1562        conn = connection or cls._connection
1563        sql = []
1564        for _index in cls.sqlmeta.indexes:
1565            if not _index:
1566                continue
1567            sql.append(conn.createIndexSQL(cls, _index))
1568        return ';\n'.join(sql)
1569
1570    @classmethod
1571    def _getJoinsToCreate(cls):
1572        joins = []
1573        for join in cls.sqlmeta.joins:
1574            if not join:
1575                continue
1576            if not join.hasIntermediateTable() or                       not getattr(join, 'createRelatedTable', True):
1578                continue
1579            if join.soClass.__name__ > join.otherClass.__name__:
1580                continue
1581            joins.append(join)
1582        return joins
1583
1584    @classmethod
1585    def dropJoinTables(cls, ifExists=False, connection=None):
1586        conn = connection or cls._connection
1587        for join in cls.sqlmeta.joins:
1588            if not join:
1589                continue
1590            if not join.hasIntermediateTable() or                       not getattr(join, 'createRelatedTable', True):
1592                continue
1593            if join.soClass.__name__ > join.otherClass.__name__:
1594                continue
1595            if ifExists and                  not conn.tableExists(join.intermediateTable):
1597                continue
1598            conn._SO_dropJoinTable(join)
1599
1600    @classmethod
1601    def clearTable(cls, connection=None, clearJoinTables=True):
1602        # 3-03 @@: Maybe this should check the cache... but it's
1603        # kind of crude anyway, so...
1604        conn = connection or cls._connection
1605        conn.clearTable(cls.sqlmeta.table)
1606        if clearJoinTables:
1607            for join in cls._getJoinsToCreate():
1608                conn.clearTable(join.intermediateTable)
1609
1610    def destroySelf(self):
1611        post_funcs = []
1612        self.sqlmeta.send(events.RowDestroySignal, self, post_funcs)
1613        # Kills this object.  Kills it dead!
1614
1615        klass = self.__class__
1616
1617        # Free related joins on the base class
1618        for join in klass.sqlmeta.joins:
1619            if isinstance(join, joins.SORelatedJoin):
1620                q = "DELETE FROM %s WHERE %s=%d" % (join.intermediateTable,
1621                                                    join.joinColumn, self.id)
1622                self._connection.query(q)
1623
1624        depends = []
1625        depends = self._SO_depends()
1626        for k in depends:
1627            # Free related joins
1628            for join in k.sqlmeta.joins:
1629                if isinstance(join, joins.SORelatedJoin) and                           join.otherClassName == klass.__name__:
1631                    q = "DELETE FROM %s WHERE %s=%d" % (join.intermediateTable,
1632                                                        join.otherColumn,
1633                                                        self.id)
1634                    self._connection.query(q)
1635
1636            cols = findDependantColumns(klass.__name__, k)
1637
1638            # Don't confuse the rest of the process
1639            if len(cols) == 0:
1640                continue
1641
1642            query = []
1643            delete = setnull = restrict = False
1644            for _col in cols:
1645                if _col.cascade is False:
1646                    # Found a restriction
1647                    restrict = True
1648                query.append(getattr(k.q, _col.name) == self.id)
1649                if _col.cascade == 'null':
1650                    setnull = _col.name
1651                elif _col.cascade:
1652                    delete = True
1653            assert delete or setnull or restrict, (
1654                "Class %s depends on %s accoriding to "
1655                "findDependantColumns, but this seems inaccurate"
1656                % (k, klass))
1657            query = sqlbuilder.OR(*query)
1658            results = k.select(query, connection=self._connection)
1659            if restrict:
1660                if results.count():
1661                    # Restrictions only apply if there are
1662                    # matching records on the related table
1663                    raise SQLObjectIntegrityError(
1664                        "Tried to delete %s::%s but "
1665                        "table %s has a restriction against it" %
1666                        (klass.__name__, self.id, k.__name__))
1667            else:
1668                for row in results:
1669                    if delete:
1670                        row.destroySelf()
1671                    else:
1672                        row.set(**{setnull: None})
1673
1674        self.sqlmeta._obsolete = True
1675        self._connection._SO_delete(self)
1676        self._connection.cache.expire(self.id, self.__class__)
1677
1678        for func in post_funcs:
1679            func(self)
1680
1681        post_funcs = []
1682        self.sqlmeta.send(events.RowDestroyedSignal, self, post_funcs)
1683        for func in post_funcs:
1684            func(self)
1685
1686    @classmethod
1687    def delete(cls, id, connection=None):
1688        obj = cls.get(id, connection=connection)
1689        obj.destroySelf()
1690
1691    @classmethod
1692    def deleteMany(cls, where=NoDefault, connection=None):
1693        conn = connection or cls._connection
1694        conn.query(conn.sqlrepr(sqlbuilder.Delete(cls.sqlmeta.table, where)))
1695
1696    @classmethod
1697    def deleteBy(cls, connection=None, **kw):
1698        conn = connection or cls._connection
1699        conn.query(conn.sqlrepr(sqlbuilder.Delete(
1700            cls.sqlmeta.table, conn._SO_columnClause(cls, kw))))
1701
1702    def __repr__(self):
1703        if not hasattr(self, 'id'):
1704            # Object initialization not finished.  No attributes can be read.
1705            return '<%s (not initialized)>' % self.__class__.__name__
1706        return '<%s %r %s>'                  % (self.__class__.__name__,
1708                  self.id,
1709                  ' '.join(
1710                      ['%s=%s' % (name, repr(value))
1711                       for name, value in self._reprItems()]))
1712
1713    def __sqlrepr__(self, db):
1714        return str(self.id)
1715
1716    @classmethod
1717    def sqlrepr(cls, value, connection=None):
1718        return (connection or cls._connection).sqlrepr(value)
1719
1720    @classmethod
1721    def coerceID(cls, value):
1722        if isinstance(value, cls):
1723            return value.id
1724        else:
1725            return cls.sqlmeta.idType(value)
1726
1727    def _reprItems(self):
1728        items = []
1729        for _col in self.sqlmeta.columnList:
1730            value = getattr(self, _col.name)
1731            r = repr(value)
1732            if len(r) > 20:
1733                value = r[:17] + "..." + r[-1]
1734            items.append((_col.name, value))
1735        return items
1736
1737    @classmethod
1738    def setConnection(cls, value):
1739        if isinstance(value, string_type):
1740            value = dbconnection.connectionForURI(value)
1741        cls._connection = value
1742
1743    def tablesUsedImmediate(self):
1744        return [self.__class__.q]
1745
1746    # hash implementation
1747
1748    def __hash__(self):
1749        # We hash on class name and id, since that should be
1750        # unique
1751        return hash((self.__class__.__name__, self.id))
1752
1753    # Comparison
1754
1755    def __eq__(self, other):
1756        if self.__class__ is other.__class__:
1757            if self.id == other.id:
1758                return True
1759        return False
1760
1761    def __ne__(self, other):
1762        return not self.__eq__(other)
1763
1764    def __lt__(self, other):
1765        return NotImplemented
1766
1767    def __le__(self, other):
1768        return NotImplemented
1769
1770    def __gt__(self, other):
1771        return NotImplemented
1772
1773    def __ge__(self, other):
1774        return NotImplemented
1775
1776    # (De)serialization (pickle, etc.)
1777
1778    def __getstate__(self):
1779        if self.sqlmeta._perConnection:
1780            from pickle import PicklingError
1781            raise PicklingError(
1782                'Cannot pickle an SQLObject instance '
1783                'that has a per-instance connection')
1784        if self.sqlmeta.lazyUpdate and self._SO_createValues:
1785            self.syncUpdate()
1786        d = self.__dict__.copy()
1787        del d['sqlmeta']
1788        del d['_SO_validatorState']
1789        del d['_SO_writeLock']
1790        del d['_SO_createValues']
1791        return d
1792
1793    def __setstate__(self, d):
1794        self.__init__(_SO_fetch_no_create=1)
1795        self._SO_validatorState = sqlbuilder.SQLObjectState(self)
1796        self._SO_writeLock = threading.Lock()
1797        self._SO_createValues = {}
1798        self.__dict__.update(d)
1799        cls = self.__class__
1800        cache = self._connection.cache
1801        if cache.tryGet(self.id, cls) is not None:
1802            raise ValueError(
1803                "Cannot unpickle %s row with id=%s - "
1804                "a different instance with the id already exists "
1805                "in the cache" % (cls.__name__, self.id))
1806        cache.created(self.id, cls, self)
1807
1808
1809def setterName(name):
1810    return '_set_%s' % name
1811
1812
1813def rawSetterName(name):
1814    return '_SO_set_%s' % name
1815
1816
1817def getterName(name):
1818    return '_get_%s' % name
1819
1820
1821def rawGetterName(name):
1822    return '_SO_get_%s' % name
1823
1824
1825def instanceName(name):
1826    return '_SO_val_%s' % name
1827
1828
1829########################################
1830# Utility functions (for external consumption)
1831########################################
1832
1833def getID(obj, refColumn=None):
1834    if isinstance(obj, SQLObject):
1835        return getattr(obj, refColumn or 'id')
1836    elif isinstance(obj, int):
1837        return obj
1838    elif isinstance(obj, long):
1839        return int(obj)
1840    elif isinstance(obj, str):
1841        try:
1842            return int(obj)
1843        except ValueError:
1844            return obj
1845    elif obj is None:
1846        return None
1847
1848
1849def getObject(obj, klass):
1850    if isinstance(obj, int):
1851        return klass(obj)
1852    elif isinstance(obj, long):
1853        return klass(int(obj))
1854    elif isinstance(obj, str):
1855        return klass(int(obj))
1856    elif obj is None:
1857        return None
1858    else:
1859        return obj
1860
1861__all__ = [
1862    'NoDefault', 'SQLObject', 'SQLObjectIntegrityError', 'SQLObjectNotFound',
1863    'getID', 'getObject', 'sqlhub', 'sqlmeta',
1864]
SQLObject-3.1.0/docs/html/sqlobject/events.py.html0000644000175000017500000023521612471401471021366 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/events.py
0001from __future__ import print_function
0002import sys
0003import types
0004from pydispatch import dispatcher
0005from weakref import ref
0006from .compat import class_types
0007
0008
0009subclassClones = {}
0010
0011
0012def listen(receiver, soClass, signal, alsoSubclasses=True, weak=True):
0013    """
0014    Listen for the given ``signal`` on the SQLObject subclass
0015    ``soClass``, calling ``receiver()`` when ``send(soClass, signal,
0016    ...)`` is called.
0017
0018    If ``alsoSubclasses`` is true, receiver will also be called when
0019    an event is fired on any subclass.
0020    """
0021    dispatcher.connect(receiver, signal=signal, sender=soClass, weak=weak)
0022    weakReceiver = ref(receiver)
0023    subclassClones.setdefault(soClass, []).append((weakReceiver, signal))
0024
0025# We export this function:
0026send = dispatcher.send
0027
0028
0029class Signal(object):
0030    """
0031    Base event for all SQLObject events.
0032
0033    In general the sender for these methods is the class, not the
0034    instance.
0035    """
0036
0037
0038class ClassCreateSignal(Signal):
0039    """
0040    Signal raised after class creation.  The sender is the superclass
0041    (in case of multiple superclasses, the first superclass).  The
0042    arguments are ``(new_class_name, bases, new_attrs, post_funcs,
0043    early_funcs)``.  ``new_attrs`` is a dictionary and may be modified
0044    (but ``new_class_name`` and ``bases`` are immutable).
0045    ``post_funcs`` is an initially-empty list that can have callbacks
0046    appended to it.
0047
0048    Note: at the time this event is called, the new class has not yet
0049    been created.  The functions in ``post_funcs`` will be called
0050    after the class is created, with the single arguments of
0051    ``(new_class)``.  Also, ``early_funcs`` will be called at the
0052    soonest possible time after class creation (``post_funcs`` is
0053    called after the class's ``__classinit__``).
0054    """
0055
0056
0057def _makeSubclassConnections(new_class_name, bases, new_attrs,
0058                             post_funcs, early_funcs):
0059    early_funcs.insert(0, _makeSubclassConnectionsPost)
0060
0061
0062def _makeSubclassConnectionsPost(new_class):
0063    for cls in new_class.__bases__:
0064        for weakReceiver, signal in subclassClones.get(cls, []):
0065            receiver = weakReceiver()
0066            if not receiver:
0067                continue
0068            listen(receiver, new_class, signal)
0069
0070dispatcher.connect(_makeSubclassConnections, signal=ClassCreateSignal)
0071
0072
0073# @@: Should there be a class reload event?  This would allow modules
0074# to be reloaded, possibly.  Or it could even be folded into
0075# ClassCreateSignal, since anything that listens to that needs to pay
0076# attention to reloads (or else it is probably buggy).
0077
0078
0079class RowCreateSignal(Signal):
0080    """
0081    Called before an instance is created, with the class as the
0082    sender.  Called with the arguments ``(instance, kwargs, post_funcs)``.
0083    There may be a ``connection`` argument.  ``kwargs``may be usefully
0084    modified.  ``post_funcs`` is a list of callbacks, intended to have
0085    functions appended to it, and are called with the arguments
0086    ``(new_instance)``.
0087
0088    Note: this is not called when an instance is created from an
0089    existing database row.
0090    """
0091
0092
0093class RowCreatedSignal(Signal):
0094    """
0095    Called after an instance is created, with the class as the
0096    sender.  Called with the arguments ``(instance, kwargs, post_funcs)``.
0097    There may be a ``connection`` argument.  ``kwargs``may be usefully
0098    modified.  ``post_funcs`` is a list of callbacks, intended to have
0099    functions appended to it, and are called with the arguments
0100    ``(new_instance)``.
0101
0102    Note: this is not called when an instance is created from an
0103    existing database row.
0104    """
0105# @@: An event for getting a row?  But for each row, when doing a
0106# select?  For .sync, .syncUpdate, .expire?
0107
0108
0109class RowDestroySignal(Signal):
0110    """
0111    Called before an instance is deleted.  Sender is the instance's
0112    class.  Arguments are ``(instance, post_funcs)``.
0113
0114    ``post_funcs`` is a list of callbacks, intended to have
0115    functions appended to it, and are called with arguments ``(instance)``.
0116    If any of the post_funcs raises an exception, the deletion is only
0117    affected if this will prevent a commit.
0118
0119    You cannot cancel the delete, but you can raise an exception (which will
0120    probably cancel the delete, but also cause an uncaught exception if not
0121    expected).
0122
0123    Note: this is not called when an instance is destroyed through
0124    garbage collection.
0125
0126    @@: Should this allow ``instance`` to be a primary key, so that a
0127    row can be deleted without first fetching it?
0128    """
0129
0130
0131class RowDestroyedSignal(Signal):
0132    """
0133    Called after an instance is deleted.  Sender is the instance's
0134    class.  Arguments are ``(instance)``.
0135
0136    This is called before the post_funcs of RowDestroySignal
0137
0138    Note: this is not called when an instance is destroyed through
0139    garbage collection.
0140    """
0141
0142
0143class RowUpdateSignal(Signal):
0144    """
0145    Called when an instance is updated through a call to ``.set()``
0146    (or a column attribute assignment).  The arguments are
0147    ``(instance, kwargs)``.  ``kwargs`` can be modified.  This is run
0148    *before* the instance is updated; if you want to look at the
0149    current values, simply look at ``instance``.
0150    """
0151
0152
0153class RowUpdatedSignal(Signal):
0154    """
0155    Called when an instance is updated through a call to ``.set()``
0156    (or a column attribute assignment).  The arguments are
0157    ``(instance, post_funcs)``. ``post_funcs`` is a list of callbacks,
0158    intended to have functions appended to it, and are called with the
0159    arguments ``(new_instance)``. This is run *after* the instance is
0160    updated; Works better with lazyUpdate = True.
0161    """
0162
0163
0164class AddColumnSignal(Signal):
0165    """
0166    Called when a column is added to a class, with arguments ``(cls,
0167    connection, column_name, column_definition, changeSchema,
0168    post_funcs)``.  This is called *after* the column has been added,
0169    and is called for each column after class creation.
0170
0171    post_funcs are called with ``(cls, so_column_obj)``
0172    """
0173
0174
0175class DeleteColumnSignal(Signal):
0176    """
0177    Called when a column is removed from a class, with the arguments
0178    ``(cls, connection, column_name, so_column_obj, post_funcs)``.
0179    Like ``AddColumnSignal`` this is called after the action has been
0180    performed, and is called for subclassing (when a column is
0181    implicitly removed by setting it to ``None``).
0182
0183    post_funcs are called with ``(cls, so_column_obj)``
0184    """
0185
0186# @@: Signals for indexes and joins?  These are mostly event consumers,
0187# though.
0188
0189
0190class CreateTableSignal(Signal):
0191    """
0192    Called when a table is created.  If ``ifNotExists==True`` and the
0193    table exists, this event is not called.
0194
0195    Called with ``(cls, connection, extra_sql, post_funcs)``.
0196    ``extra_sql`` is a list (which can be appended to) of extra SQL
0197    statements to be run after the table is created.  ``post_funcs``
0198    functions are called with ``(cls, connection)`` after the table
0199    has been created.  Those functions are *not* called simply when
0200    constructing the SQL.
0201    """
0202
0203
0204class DropTableSignal(Signal):
0205    """
0206    Called when a table is dropped.  If ``ifExists==True`` and the
0207    table doesn't exist, this event is not called.
0208
0209    Called with ``(cls, connection, extra_sql, post_funcs)``.
0210    ``post_funcs`` functions are called with ``(cls, connection)``
0211    after the table has been dropped.
0212    """
0213
0214############################################################
0215# Event Debugging
0216############################################################
0217
0218
0219def summarize_events_by_sender(sender=None, output=None, indent=0):
0220    """
0221    Prints out a summary of the senders and listeners in the system,
0222    for debugging purposes.
0223    """
0224    if output is None:
0225        output = sys.stdout
0226    leader = ' ' * indent
0227    if sender is None:
0228        send_list = [
0229            (deref(dispatcher.senders.get(sid)), listeners)
0230            for sid, listeners in dispatcher.connections.items()
0231            if deref(dispatcher.senders.get(sid))]
0232        for sender, listeners in sorted_items(send_list):
0233            real_sender = deref(sender)
0234            if not real_sender:
0235                continue
0236            header = 'Sender: %r' % real_sender
0237            print(leader + header, file=output)
0238            print(leader + ('=' * len(header)), file=output)
0239            summarize_events_by_sender(real_sender, output=output,
0240                                       indent=indent + 2)
0241    else:
0242        for signal, receivers in                   sorted_items(dispatcher.connections.get(id(sender), [])):
0244            receivers = [deref(r) for r in receivers if deref(r)]
0245            header = 'Signal: %s (%i receivers)' % (sort_name(signal),
0246                                                    len(receivers))
0247            print(leader + header, file=output)
0248            print(leader + ('-' * len(header)), file=output)
0249            for receiver in sorted(receivers, key=sort_name):
0250                print(leader + '  ' + nice_repr(receiver), file=output)
0251
0252
0253def deref(value):
0254    if isinstance(value, dispatcher.WEAKREF_TYPES):
0255        return value()
0256    else:
0257        return value
0258
0259
0260def sorted_items(a_dict):
0261    if isinstance(a_dict, dict):
0262        a_dict = a_dict.items()
0263    return sorted(a_dict, key=lambda t: sort_name(t[0]))
0264
0265
0266def sort_name(value):
0267    if isinstance(value, type):
0268        return value.__name__
0269    elif isinstance(value, types.FunctionType):
0270        return value.__name__
0271    else:
0272        return str(value)
0273
0274_real_dispatcher_send = dispatcher.send
0275_real_dispatcher_sendExact = dispatcher.sendExact
0276_real_dispatcher_connect = dispatcher.connect
0277_real_dispatcher_disconnect = dispatcher.disconnect
0278_debug_enabled = False
0279
0280
0281def debug_events():
0282    global _debug_enabled, send
0283    if _debug_enabled:
0284        return
0285    _debug_enabled = True
0286    dispatcher.send = send = _debug_send
0287    dispatcher.sendExact = _debug_sendExact
0288    dispatcher.disconnect = _debug_disconnect
0289    dispatcher.connect = _debug_connect
0290
0291
0292def _debug_send(signal=dispatcher.Any, sender=dispatcher.Anonymous,
0293                *arguments, **named):
0294    print("send %s from %s: %s" % (
0295          nice_repr(signal), nice_repr(sender),
0296          fmt_args(*arguments, **named)))
0297    return _real_dispatcher_send(signal, sender, *arguments, **named)
0298
0299
0300def _debug_sendExact(signal=dispatcher.Any, sender=dispatcher.Anonymous,
0301                     *arguments, **named):
0302    print("sendExact %s from %s: %s" % (
0303          nice_repr(signal), nice_repr(sender), fmt_args(*arguments, **name)))
0304    return _real_dispatcher_sendExact(signal, sender, *arguments, **named)
0305
0306
0307def _debug_connect(receiver, signal=dispatcher.Any, sender=dispatcher.Any,
0308                   weak=True):
0309    print("connect %s to %s signal %s" % (
0310          nice_repr(receiver), nice_repr(signal), nice_repr(sender)))
0311    return _real_dispatcher_connect(receiver, signal, sender, weak)
0312
0313
0314def _debug_disconnect(receiver, signal=dispatcher.Any, sender=dispatcher.Any,
0315                      weak=True):
0316    print("disconnecting %s from %s signal %s" % (
0317          nice_repr(receiver), nice_repr(signal), nice_repr(sender)))
0318    return _real_dispatcher_disconnect(receiver, signal, sender, weak)
0319
0320
0321def fmt_args(*arguments, **name):
0322    args = [repr(a) for a in arguments]
0323    args.extend([
0324        '%s=%r' % (n, v) for n, v in sorted(name.items())])
0325    return ', '.join(args)
0326
0327
0328def nice_repr(v):
0329    """
0330    Like repr(), but nicer for debugging here.
0331    """
0332    if isinstance(v, class_types):
0333        return v.__module__ + '.' + v.__name__
0334    elif isinstance(v, types.FunctionType):
0335        if '__name__' in v.__globals__:
0336            if getattr(sys.modules[v.__globals__['__name__']],
0337                       v.__name__, None) is v:
0338                return '%s.%s' % (v.__globals__['__name__'], v.__name__)
0339        return repr(v)
0340    elif isinstance(v, types.MethodType):
0341        return '%s.%s of %s' % (
0342            nice_repr(v.__self__.__class__), v.__func__.__name__,
0343            nice_repr(v.__self__))
0344    else:
0345        return repr(v)
0346
0347
0348__all__ = ['listen', 'send']
0349# Use copy() to avoid 'dictionary changed' issues on python 3
0350for name, value in globals().copy().items():
0351    if isinstance(value, type) and issubclass(value, Signal):
0352        __all__.append(name)
SQLObject-3.1.0/docs/html/sqlobject/inheritance/0000755000175000017500000000000012754657361021044 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/inheritance/__init__.py.html0000644000175000017500000053006212471401471024107 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/inheritance/__init__.py
0001from functools import reduce
0002
0003from sqlobject import dbconnection
0004from sqlobject import classregistry
0005from sqlobject import events
0006from sqlobject import sqlbuilder
0007from sqlobject.col import StringCol, ForeignKey
0008from sqlobject.main import sqlmeta, SQLObject, SelectResults,       makeProperties, unmakeProperties, getterName, setterName
0010from sqlobject.compat import string_type
0011from . import iteration
0012
0013
0014def tablesUsedSet(obj, db):
0015    if hasattr(obj, "tablesUsedSet"):
0016        return obj.tablesUsedSet(db)
0017    elif isinstance(obj, (tuple, list, set, frozenset)):
0018        s = set()
0019        for component in obj:
0020            s.update(tablesUsedSet(component, db))
0021        return s
0022    else:
0023        return set()
0024
0025
0026class InheritableSelectResults(SelectResults):
0027    IterationClass = iteration.InheritableIteration
0028
0029    def __init__(self, sourceClass, clause, clauseTables=None,
0030                 inheritedTables=None, **ops):
0031        if clause is None or isinstance(clause, str) and clause == 'all':
0032            clause = sqlbuilder.SQLTrueClause
0033
0034        dbName = (ops.get('connection', None) or
0035                  sourceClass._connection).dbName
0036
0037        tablesSet = tablesUsedSet(clause, dbName)
0038        tablesSet.add(str(sourceClass.sqlmeta.table))
0039        orderBy = ops.get('orderBy')
0040        if inheritedTables:
0041            for tableName in inheritedTables:
0042                tablesSet.add(str(tableName))
0043        if orderBy and not isinstance(orderBy, string_type):
0044            tablesSet.update(tablesUsedSet(orderBy, dbName))
0045        # DSM: if this class has a parent, we need to link it
0046        # DSM: and be sure the parent is in the table list.
0047        # DSM: The following code is before clauseTables
0048        # DSM: because if the user uses clauseTables
0049        # DSM: (and normal string SELECT), he must know what he wants
0050        # DSM: and will do himself the relationship between classes.
0051        if not isinstance(clause, str):
0052            tableRegistry = {}
0053            allClasses = classregistry.registry(
0054                sourceClass.sqlmeta.registry).allClasses()
0055            for registryClass in allClasses:
0056                if str(registryClass.sqlmeta.table) in tablesSet:
0057                    # DSM: By default, no parents are needed for the clauses
0058                    tableRegistry[registryClass] = registryClass
0059            tableRegistryCopy = tableRegistry.copy()
0060            for childClass in tableRegistryCopy:
0061                if childClass not in tableRegistry:
0062                    continue
0063                currentClass = childClass
0064                while currentClass:
0065                    if currentClass in tableRegistryCopy:
0066                        if currentClass in tableRegistry:
0067                            # DSM: Remove this class as it is a parent one
0068                            # DSM: of a needed children
0069                            del tableRegistry[currentClass]
0070                        # DSM: Must keep the last parent needed
0071                        # DSM: (to limit the number of join needed)
0072                        tableRegistry[childClass] = currentClass
0073                    currentClass = currentClass.sqlmeta.parentClass
0074            # DSM: Table registry contains only the last children
0075            # DSM: or standalone classes
0076            parentClause = []
0077            for (currentClass, minParentClass) in tableRegistry.items():
0078                while (currentClass != minParentClass)                           and currentClass.sqlmeta.parentClass:
0080                    parentClass = currentClass.sqlmeta.parentClass
0081                    parentClause.append(currentClass.q.id == parentClass.q.id)
0082                    currentClass = parentClass
0083                    tablesSet.add(str(currentClass.sqlmeta.table))
0084            clause = reduce(sqlbuilder.AND, parentClause, clause)
0085
0086        super(InheritableSelectResults, self).__init__(
0087            sourceClass, clause, clauseTables, **ops)
0088
0089    def accumulateMany(self, *attributes, **kw):
0090        if kw.get("skipInherited"):
0091            return super(InheritableSelectResults, self).                  accumulateMany(*attributes)
0093        tables = []
0094        for func_name, attribute in attributes:
0095            if not isinstance(attribute, string_type):
0096                tables.append(attribute.tableName)
0097        clone = self.__class__(self.sourceClass, self.clause,
0098                               self.clauseTables, inheritedTables=tables,
0099                               **self.ops)
0100        return clone.accumulateMany(skipInherited=True, *attributes)
0101
0102
0103class InheritableSQLMeta(sqlmeta):
0104    @classmethod
0105    def addColumn(sqlmeta, columnDef, changeSchema=False, connection=None,
0106                  childUpdate=False):
0107        soClass = sqlmeta.soClass
0108        # DSM: Try to add parent properties to the current class
0109        # DSM: Only do this once if possible at object creation and once for
0110        # DSM: each new dynamic column to refresh the current class
0111        if sqlmeta.parentClass:
0112            for col in sqlmeta.parentClass.sqlmeta.columnList:
0113                cname = col.name
0114                if cname == 'childName':
0115                    continue
0116                if cname.endswith("ID"):
0117                    cname = cname[:-2]
0118                setattr(soClass, getterName(cname), eval(
0119                    'lambda self: self._parent.%s' % cname))
0120                if not col.immutable:
0121                    def make_setfunc(cname):
0122                        def setfunc(self, val):
0123                            if not self.sqlmeta._creating and                                  not getattr(self.sqlmeta,
0125                                           "row_update_sig_suppress", False):
0126                                self.sqlmeta.send(events.RowUpdateSignal, self,
0127                                                  {cname: val})
0128
0129                            setattr(self._parent, cname, val)
0130                        return setfunc
0131
0132                    setfunc = make_setfunc(cname)
0133                    setattr(soClass, setterName(cname), setfunc)
0134            if childUpdate:
0135                makeProperties(soClass)
0136                return
0137
0138        if columnDef:
0139            super(InheritableSQLMeta, sqlmeta).addColumn(columnDef,
0140                                                         changeSchema,
0141                                                         connection)
0142
0143        # DSM: Update each child class if needed and existing (only for new
0144        # DSM: dynamic column as no child classes exists at object creation)
0145        if columnDef and hasattr(soClass, "q"):
0146            q = getattr(soClass.q, columnDef.name, None)
0147        else:
0148            q = None
0149        for c in sqlmeta.childClasses.values():
0150            c.sqlmeta.addColumn(columnDef, connection=connection,
0151                                childUpdate=True)
0152            if q:
0153                setattr(c.q, columnDef.name, q)
0154
0155    @classmethod
0156    def delColumn(sqlmeta, column, changeSchema=False, connection=None,
0157                  childUpdate=False):
0158        if childUpdate:
0159            soClass = sqlmeta.soClass
0160            unmakeProperties(soClass)
0161            makeProperties(soClass)
0162
0163            if isinstance(column, str):
0164                name = column
0165            else:
0166                name = column.name
0167            delattr(soClass, name)
0168            delattr(soClass.q, name)
0169            return
0170
0171        super(InheritableSQLMeta, sqlmeta).delColumn(column, changeSchema,
0172                                                     connection)
0173
0174        # DSM: Update each child class if needed
0175        # DSM: and delete properties for this column
0176        for c in sqlmeta.childClasses.values():
0177            c.sqlmeta.delColumn(column, changeSchema=changeSchema,
0178                                connection=connection, childUpdate=True)
0179
0180    @classmethod
0181    def addJoin(sqlmeta, joinDef, childUpdate=False):
0182        soClass = sqlmeta.soClass
0183        # DSM: Try to add parent properties to the current class
0184        # DSM: Only do this once if possible at object creation and once for
0185        # DSM: each new dynamic join to refresh the current class
0186        if sqlmeta.parentClass:
0187            for join in sqlmeta.parentClass.sqlmeta.joins:
0188                jname = join.joinMethodName
0189                jarn = join.addRemoveName
0190                setattr(
0191                    soClass, getterName(jname),
0192                    eval('lambda self: self._parent.%s' % jname))
0193                if hasattr(join, 'remove'):
0194                    setattr(
0195                        soClass, 'remove' + jarn,
0196                        eval('lambda self,o: self._parent.remove%s(o)' % jarn))
0197                if hasattr(join, 'add'):
0198                    setattr(
0199                        soClass, 'add' + jarn,
0200                        eval('lambda self,o: self._parent.add%s(o)' % jarn))
0201            if childUpdate:
0202                makeProperties(soClass)
0203                return
0204
0205        if joinDef:
0206            super(InheritableSQLMeta, sqlmeta).addJoin(joinDef)
0207
0208        # DSM: Update each child class if needed and existing (only for new
0209        # DSM: dynamic join as no child classes exists at object creation)
0210        for c in sqlmeta.childClasses.values():
0211            c.sqlmeta.addJoin(joinDef, childUpdate=True)
0212
0213    @classmethod
0214    def delJoin(sqlmeta, joinDef, childUpdate=False):
0215        if childUpdate:
0216            soClass = sqlmeta.soClass
0217            unmakeProperties(soClass)
0218            makeProperties(soClass)
0219            return
0220
0221        super(InheritableSQLMeta, sqlmeta).delJoin(joinDef)
0222
0223        # DSM: Update each child class if needed
0224        # DSM: and delete properties for this join
0225        for c in sqlmeta.childClasses.values():
0226            c.sqlmeta.delJoin(joinDef, childUpdate=True)
0227
0228    @classmethod
0229    def getAllColumns(sqlmeta):
0230        columns = sqlmeta.columns.copy()
0231        sm = sqlmeta
0232        while sm.parentClass:
0233            columns.update(sm.parentClass.sqlmeta.columns)
0234            sm = sm.parentClass.sqlmeta
0235        return columns
0236
0237    @classmethod
0238    def getColumns(sqlmeta):
0239        columns = sqlmeta.getAllColumns()
0240        if 'childName' in columns:
0241            del columns['childName']
0242        return columns
0243
0244
0245class InheritableSQLObject(SQLObject):
0246
0247    sqlmeta = InheritableSQLMeta
0248    _inheritable = True
0249    SelectResultsClass = InheritableSelectResults
0250
0251    def set(self, **kw):
0252        if self._parent:
0253            SQLObject.set(self, _suppress_set_sig=True, **kw)
0254        else:
0255            SQLObject.set(self, **kw)
0256
0257    def __classinit__(cls, new_attrs):
0258        SQLObject.__classinit__(cls, new_attrs)
0259        # if we are a child class, add sqlbuilder fields from parents
0260        currentClass = cls.sqlmeta.parentClass
0261        while currentClass:
0262            for column in currentClass.sqlmeta.columnDefinitions.values():
0263                if column.name == 'childName':
0264                    continue
0265                if isinstance(column, ForeignKey):
0266                    continue
0267                setattr(cls.q, column.name,
0268                        getattr(currentClass.q, column.name))
0269            currentClass = currentClass.sqlmeta.parentClass
0270
0271    @classmethod
0272    def _SO_setupSqlmeta(cls, new_attrs, is_base):
0273        # Note: cannot use super(InheritableSQLObject, cls)._SO_setupSqlmeta -
0274        #       InheritableSQLObject is not defined when it's __classinit__
0275        #       is run.  Cannot use SQLObject._SO_setupSqlmeta, either:
0276        #       the method would be bound to wrong class.
0277        if cls.__name__ == "InheritableSQLObject":
0278            call_super = super(cls, cls)
0279        else:
0280            # InheritableSQLObject must be in globals yet
0281            call_super = super(InheritableSQLObject, cls)
0282        call_super._SO_setupSqlmeta(new_attrs, is_base)
0283        sqlmeta = cls.sqlmeta
0284        sqlmeta.childClasses = {}
0285        # locate parent class and register this class in it's children
0286        sqlmeta.parentClass = None
0287        for superclass in cls.__bases__:
0288            if getattr(superclass, '_inheritable', False)                       and (superclass.__name__ != 'InheritableSQLObject'):
0290                if sqlmeta.parentClass:
0291                    # already have a parent class;
0292                    # cannot inherit from more than one
0293                    raise NotImplementedError(
0294                        "Multiple inheritance is not implemented")
0295                sqlmeta.parentClass = superclass
0296                superclass.sqlmeta.childClasses[cls.__name__] = cls
0297        if sqlmeta.parentClass:
0298            # remove inherited column definitions
0299            cls.sqlmeta.columns = {}
0300            cls.sqlmeta.columnList = []
0301            cls.sqlmeta.columnDefinitions = {}
0302            # default inheritance child name
0303            if not sqlmeta.childName:
0304                sqlmeta.childName = cls.__name__
0305
0306    @classmethod
0307    def get(cls, id, connection=None, selectResults=None,
0308            childResults=None, childUpdate=False):
0309
0310        val = super(InheritableSQLObject, cls).get(id, connection,
0311                                                   selectResults)
0312
0313        # DSM: If we are updating a child, we should never return a child...
0314        if childUpdate:
0315            return val
0316        # DSM: If this class has a child, return the child
0317        if 'childName' in cls.sqlmeta.columns:
0318            childName = val.childName
0319            if childName is not None:
0320                childClass = cls.sqlmeta.childClasses[childName]
0321                # If the class has no columns (which sometimes makes sense
0322                # and may be true for non-inheritable (leaf) classes only),
0323                # shunt the query to avoid almost meaningless SQL
0324                # like "SELECT NULL FROM child WHERE id=1".
0325                # This is based on assumption that child object exists
0326                # if parent object exists.  (If it doesn't your database
0327                # is broken and that is a job for database maintenance.)
0328                if not (childResults or childClass.sqlmeta.columns):
0329                    childResults = (None,)
0330                return childClass.get(id, connection=connection,
0331                                      selectResults=childResults)
0332        # DSM: Now, we know we are alone or the last child in a family...
0333        # DSM: It's time to find our parents
0334        inst = val
0335        while inst.sqlmeta.parentClass and not inst._parent:
0336            inst._parent = inst.sqlmeta.parentClass.get(
0337                id, connection=connection, childUpdate=True)
0338            inst = inst._parent
0339        # DSM: We can now return ourself
0340        return val
0341
0342    @classmethod
0343    def _notifyFinishClassCreation(cls):
0344        sqlmeta = cls.sqlmeta
0345        # verify names of added columns
0346        if sqlmeta.parentClass:
0347            # FIXME: this does not check for grandparent column overrides
0348            parentCols = sqlmeta.parentClass.sqlmeta.columns.keys()
0349            for column in sqlmeta.columnList:
0350                if column.name == 'childName':
0351                    raise AttributeError(
0352                        "The column name 'childName' is reserved")
0353                if column.name in parentCols:
0354                    raise AttributeError(
0355                        "The column '%s' is already defined "
0356                        "in an inheritable parent" % column.name)
0357        # if this class is inheritable, add column for children distinction
0358        if cls._inheritable and (cls.__name__ != 'InheritableSQLObject'):
0359            sqlmeta.addColumn(
0360                StringCol(name='childName',
0361                          # limit string length to get VARCHAR and not CLOB
0362                          length=255, default=None))
0363        if not sqlmeta.columnList:
0364            # There are no columns - call addColumn to propagate columns
0365            # from parent classes to children
0366            sqlmeta.addColumn(None)
0367        if not sqlmeta.joins:
0368            # There are no joins - call addJoin to propagate joins
0369            # from parent classes to children
0370            sqlmeta.addJoin(None)
0371
0372    def _create(self, id, **kw):
0373
0374        # DSM: If we were called by a children class,
0375        # DSM: we must retreive the properties dictionary.
0376        # DSM: Note: we can't use the ** call paremeter directly
0377        # DSM: as we must be able to delete items from the dictionary
0378        # DSM: (and our children must know that the items were removed!)
0379        if 'kw' in kw:
0380            kw = kw['kw']
0381        # DSM: If we are the children of an inheritable class,
0382        # DSM: we must first create our parent
0383        if self.sqlmeta.parentClass:
0384            parentClass = self.sqlmeta.parentClass
0385            new_kw = {}
0386            parent_kw = {}
0387            for (name, value) in kw.items():
0388                if (name != 'childName') and hasattr(parentClass, name):
0389                    parent_kw[name] = value
0390                else:
0391                    new_kw[name] = value
0392            kw = new_kw
0393
0394            # Need to check that we have enough data to sucesfully
0395            # create the current subclass otherwise we will leave
0396            # the database in an inconsistent state.
0397            for col in self.sqlmeta.columnList:
0398                if (col._default == sqlbuilder.NoDefault) and                           (col.name not in kw) and (col.foreignName not in kw):
0400                    raise TypeError(
0401                        "%s() did not get expected keyword argument "
0402                        "%s" % (self.__class__.__name__, col.name))
0403
0404            parent_kw['childName'] = self.sqlmeta.childName
0405            self._parent = parentClass(kw=parent_kw,
0406                                       connection=self._connection)
0407
0408            id = self._parent.id
0409
0410        # TC: Create this record and catch all exceptions in order to destroy
0411        # TC: the parent if the child can not be created.
0412        try:
0413            super(InheritableSQLObject, self)._create(id, **kw)
0414        except:
0415            # If we are outside a transaction and this is a child,
0416            # destroy the parent
0417            connection = self._connection
0418            if (not isinstance(connection, dbconnection.Transaction) and
0419                    connection.autoCommit) and self.sqlmeta.parentClass:
0420                self._parent.destroySelf()
0421                # TC: Do we need to do this??
0422                self._parent = None
0423            # TC: Reraise the original exception
0424            raise
0425
0426    @classmethod
0427    def _findAlternateID(cls, name, dbName, value, connection=None):
0428        result = list(cls.selectBy(connection, **{name: value}))
0429        if not result:
0430            return result, None
0431        obj = result[0]
0432        return [obj.id], obj
0433
0434    @classmethod
0435    def select(cls, clause=None, *args, **kwargs):
0436        parentClass = cls.sqlmeta.parentClass
0437        childUpdate = kwargs.pop('childUpdate', None)
0438        # childUpdate may have one of three values:
0439        #   True:
0440        #       select was issued by parent class to create child objects.
0441        #       Execute select without modifications.
0442        #   None (default):
0443        #       select is run by application.  If this class is inheritance
0444        #       child, delegate query to the parent class to utilize
0445        #       InheritableIteration optimizations.  Selected records
0446        #       are restricted to this (child) class by adding childName
0447        #       filter to the where clause.
0448        #   False:
0449        #       select is delegated from inheritance child which is parent
0450        #       of another class.  Delegate the query to parent if possible,
0451        #       but don't add childName restriction: selected records
0452        #       will be filtered by join to the table filtered by childName.
0453        if (not childUpdate) and parentClass:
0454            if childUpdate is None:
0455                # this is the first parent in deep hierarchy
0456                addClause = parentClass.q.childName == cls.sqlmeta.childName
0457                # if the clause was one of TRUE varians, replace it
0458                if (clause is None) or (clause is sqlbuilder.SQLTrueClause)                           or (
0460                            isinstance(clause, string_type) and
0461                            (clause == 'all')):
0462                    clause = addClause
0463                else:
0464                    # patch WHERE condition:
0465                    # change ID field of this class to ID of parent class
0466                    # XXX the clause is patched in place; it would be better
0467                    #     to build a new one if we have to replace field
0468                    clsID = cls.q.id
0469                    parentID = parentClass.q.id
0470
0471                    def _get_patched(clause):
0472                        if isinstance(clause, sqlbuilder.SQLOp):
0473                            _patch_id_clause(clause)
0474                            return None
0475                        elif not isinstance(clause, sqlbuilder.Field):
0476                            return None
0477                        elif (clause.tableName == clsID.tableName)                                   and (clause.fieldName == clsID.fieldName):
0479                            return parentID
0480                        else:
0481                            return None
0482
0483                    def _patch_id_clause(clause):
0484                        if not isinstance(clause, sqlbuilder.SQLOp):
0485                            return
0486                        expr = _get_patched(clause.expr1)
0487                        if expr:
0488                            clause.expr1 = expr
0489                        expr = _get_patched(clause.expr2)
0490                        if expr:
0491                            clause.expr2 = expr
0492                    _patch_id_clause(clause)
0493                    # add childName filter
0494                    clause = sqlbuilder.AND(clause, addClause)
0495            return parentClass.select(clause, childUpdate=False,
0496                                      *args, **kwargs)
0497        else:
0498            return super(InheritableSQLObject, cls).select(
0499                clause, *args, **kwargs)
0500
0501    @classmethod
0502    def selectBy(cls, connection=None, **kw):
0503        clause = []
0504        foreignColumns = {}
0505        currentClass = cls
0506        while currentClass:
0507            foreignColumns.update(dict(
0508                [(column.foreignName, name)
0509                    for (name, column) in currentClass.sqlmeta.columns.items()
0510                    if column.foreignKey
0511                 ]))
0512            currentClass = currentClass.sqlmeta.parentClass
0513        for name, value in kw.items():
0514            if name in foreignColumns:
0515                name = foreignColumns[name]  # translate "key" to "keyID"
0516                if isinstance(value, SQLObject):
0517                    value = value.id
0518            currentClass = cls
0519            while currentClass:
0520                try:
0521                    clause.append(getattr(currentClass.q, name) == value)
0522                    break
0523                except AttributeError:
0524                    pass
0525                currentClass = currentClass.sqlmeta.parentClass
0526            else:
0527                raise AttributeError(
0528                    "'%s' instance has no attribute '%s'" % (
0529                        cls.__name__, name))
0530        if clause:
0531            clause = reduce(sqlbuilder.AND, clause)
0532        else:
0533            clause = None  # select all
0534        conn = connection or cls._connection
0535        return cls.SelectResultsClass(cls, clause, connection=conn)
0536
0537    def destroySelf(self):
0538        # DSM: If this object has parents, recursivly kill them
0539        if hasattr(self, '_parent') and self._parent:
0540            self._parent.destroySelf()
0541        super(InheritableSQLObject, self).destroySelf()
0542
0543    def _reprItems(self):
0544        items = super(InheritableSQLObject, self)._reprItems()
0545        # add parent attributes (if any)
0546        if self.sqlmeta.parentClass:
0547            items.extend(self._parent._reprItems())
0548        # filter out our special column
0549        return [item for item in items if item[0] != 'childName']
0550
0551__all__ = ['InheritableSQLObject']
SQLObject-3.1.0/docs/html/sqlobject/index.py.html0000644000175000017500000015363612470115365021201 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/index.py
0001from itertools import count
0002from .converters import sqlrepr
0003
0004
0005creationOrder = count()
0006
0007
0008class SODatabaseIndex(object):
0009
0010    def __init__(self,
0011                 soClass,
0012                 name,
0013                 columns,
0014                 creationOrder,
0015                 unique=False):
0016        self.soClass = soClass
0017        self.name = name
0018        self.descriptions = self.convertColumns(columns)
0019        self.creationOrder = creationOrder
0020        self.unique = unique
0021
0022    def get(self, *args, **kw):
0023        if not self.unique:
0024            raise AttributeError(
0025                "'%s' object has no attribute 'get' "
0026                "(index is not unique)" % self.name)
0027        connection = kw.pop('connection', None)
0028        if args and kw:
0029            raise TypeError("You cannot mix named and unnamed arguments")
0030        columns = [d['column'] for d in self.descriptions if 'column' in d]
0031        if kw and len(kw) != len(columns) or                   args and len(args) != len(columns):
0033            raise TypeError(
0034                "get() takes exactly %d argument and an optional "
0035                "named argument 'connection' (%d given)" % (
0036                    len(columns), len(args) + len(kw)))
0037        if args:
0038            kw = {}
0039            for i in range(len(args)):
0040                if columns[i].foreignName is not None:
0041                    kw[columns[i].foreignName] = args[i]
0042                else:
0043                    kw[columns[i].name] = args[i]
0044        return self.soClass.selectBy(connection=connection, **kw).getOne()
0045
0046    def convertColumns(self, columns):
0047        """
0048        Converts all the columns to dictionary descriptors;
0049        dereferences string column names.
0050        """
0051        new = []
0052        for desc in columns:
0053            if not isinstance(desc, dict):
0054                desc = {'column': desc}
0055            if 'expression' in desc:
0056                assert 'column' not in desc, (
0057                    'You cannot provide both an expression and a column '
0058                    '(for %s in index %s in %s)' %
0059                    (desc, self.name, self.soClass))
0060                assert 'length' not in desc, (
0061                    'length does not apply to expressions (for %s in '
0062                    'index %s in %s)' %
0063                    (desc, self.name, self.soClass))
0064                new.append(desc)
0065                continue
0066            columnName = desc['column']
0067            if not isinstance(columnName, str):
0068                columnName = columnName.name
0069            colDict = self.soClass.sqlmeta.columns
0070            if columnName not in colDict:
0071                for possible in colDict.values():
0072                    if possible.origName == columnName:
0073                        column = possible
0074                        break
0075                else:
0076                    # None found
0077                    raise ValueError(
0078                        "The column by the name %r was not found "
0079                        "in the class %r" % (columnName, self.soClass))
0080            else:
0081                column = colDict[columnName]
0082            desc['column'] = column
0083            new.append(desc)
0084        return new
0085
0086    def getExpression(self, desc, db):
0087        if isinstance(desc['expression'], str):
0088            return desc['expression']
0089        else:
0090            return sqlrepr(desc['expression'], db)
0091
0092    def sqliteCreateIndexSQL(self, soClass):
0093        if self.unique:
0094            uniqueOrIndex = 'UNIQUE INDEX'
0095        else:
0096            uniqueOrIndex = 'INDEX'
0097        spec = []
0098        for desc in self.descriptions:
0099            if 'expression' in desc:
0100                spec.append(self.getExpression(desc, 'sqlite'))
0101            else:
0102                spec.append(desc['column'].dbName)
0103        ret = 'CREATE %s %s_%s ON %s (%s)' %                 (uniqueOrIndex,
0105               self.soClass.sqlmeta.table,
0106               self.name,
0107               self.soClass.sqlmeta.table,
0108               ', '.join(spec))
0109        return ret
0110
0111    postgresCreateIndexSQL = maxdbCreateIndexSQL = mssqlCreateIndexSQL =           sybaseCreateIndexSQL = firebirdCreateIndexSQL = sqliteCreateIndexSQL
0113
0114    def mysqlCreateIndexSQL(self, soClass):
0115        if self.unique:
0116            uniqueOrIndex = 'UNIQUE'
0117        else:
0118            uniqueOrIndex = 'INDEX'
0119        spec = []
0120        for desc in self.descriptions:
0121            if 'expression' in desc:
0122                spec.append(self.getExpression(desc, 'mysql'))
0123            elif 'length' in desc:
0124                spec.append('%s(%d)' % (desc['column'].dbName, desc['length']))
0125            else:
0126                spec.append(desc['column'].dbName)
0127
0128        return 'ALTER TABLE %s ADD %s %s (%s)' %                  (soClass.sqlmeta.table, uniqueOrIndex,
0130                self.name,
0131                ', '.join(spec))
0132
0133
0134class DatabaseIndex(object):
0135    """
0136    This takes a variable number of parameters, each of which is a
0137    column for indexing.  Each column may be a column object or the
0138    string name of the column (*not* the database name).  You may also
0139    use dictionaries, to further customize the indexing of the column.
0140    The dictionary may have certain keys:
0141
0142    'column':
0143        The column object or string identifier.
0144    'length':
0145        MySQL will only index the first N characters if this is
0146        given.  For other databases this is ignored.
0147    'expression':
0148        You can create an index based on an expression, e.g.,
0149        'lower(column)'.  This can either be a string or a sqlbuilder
0150        expression.
0151
0152    Further keys may be added to the column specs in the future.
0153
0154    The class also take the keyword argument `unique`; if true then
0155    a UNIQUE index is created.
0156    """
0157
0158    baseClass = SODatabaseIndex
0159
0160    def __init__(self, *columns, **kw):
0161        kw['columns'] = columns
0162        self.kw = kw
0163        self.creationOrder = next(creationOrder)
0164
0165    def setName(self, value):
0166        assert self.kw.get('name') is None,               "You cannot change a name after it has already been set "               "(from %s to %s)" % (self.kw['name'], value)
0169        self.kw['name'] = value
0170
0171    def _get_name(self):
0172        return self.kw['name']
0173
0174    def _set_name(self, value):
0175        self.setName(value)
0176
0177    name = property(_get_name, _set_name)
0178
0179    def withClass(self, soClass):
0180        return self.baseClass(soClass=soClass,
0181                              creationOrder=self.creationOrder, **self.kw)
0182
0183    def __repr__(self):
0184        return '<%s %s %s>' % (
0185            self.__class__.__name__,
0186            hex(abs(id(self)))[2:],
0187            self.kw)
0188
0189__all__ = ['DatabaseIndex']
SQLObject-3.1.0/docs/html/sqlobject/sqlbuilder.py.html0000644000175000017500000144421412753527207022242 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/sqlbuilder.py
0001"""
0002sqlobject.sqlbuilder
0003--------------------
0004
0005:author: Ian Bicking <ianb@colorstudy.com>
0006
0007Builds SQL expressions from normal Python expressions.
0008
0009Disclaimer
0010----------
0011
0012This program is free software; you can redistribute it and/or modify
0013it under the terms of the GNU Lesser General Public License as
0014published by the Free Software Foundation; either version 2.1 of the
0015License, or (at your option any later version.
0016
0017This program is distributed in the hope that it will be useful,
0018but WITHOUT ANY WARRANTY; without even the implied warranty of
0019MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0020GNU General Public License for more details.
0021
0022You should have received a copy of the GNU Lesser General Public
0023License along with this program; if not, write to the Free Software
0024Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301,
0025USA.
0026
0027Instructions
0028------------
0029
0030To begin a SQL expression, you must use some sort of SQL object -- a
0031field, table, or SQL statement (``SELECT``, ``INSERT``, etc.)  You can
0032then use normal operators, with the exception of: `and`, `or`, `not`,
0033and `in`.  You can use the `AND`, `OR`, `NOT`, and `IN` functions
0034instead, or you can also use `&`, `|`, and `~` for `and`, `or`, and
0035`not` respectively (however -- the precidence for these operators
0036doesn't work as you would want, so you must use many parenthesis).
0037
0038To create a sql field, table, or constant/function, use the namespaces
0039`table`, `const`, and `func`.  For instance, ``table.address`` refers
0040to the ``address`` table, and ``table.address.state`` refers to the
0041``state`` field in the address table.  ``const.NULL`` is the ``NULL``
0042SQL constant, and ``func.NOW()`` is the ``NOW()`` function call
0043(`const` and `func` are actually identicle, but the two names are
0044provided for clarity).  Once you create this object, expressions
0045formed with it will produce SQL statements.
0046
0047The ``sqlrepr(obj)`` function gets the SQL representation of these
0048objects, as well as the proper SQL representation of basic Python
0049types (None==NULL).
0050
0051There are a number of DB-specific SQL features that this does not
0052implement.  There are a bunch of normal ANSI features also not present.
0053
0054See the bottom of this module for some examples, and run it (i.e.
0055``python sql.py``) to see the results of those examples.
0056
0057"""
0058
0059########################################
0060# Constants
0061########################################
0062
0063import fnmatch
0064import operator
0065import re
0066import threading
0067import types
0068import weakref
0069
0070from . import classregistry
0071from .converters import registerConverter, sqlrepr, quote_str, unquote_str
0072from .compat import PY2, string_type
0073
0074
0075class VersionError(Exception):
0076    pass
0077
0078
0079class NoDefault:
0080    pass
0081
0082
0083class SQLObjectState(object):
0084    def __init__(self, soObject, connection=None):
0085        self.soObject = weakref.proxy(soObject)
0086        self.connection = connection
0087
0088
0089safeSQLRE = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_\.]*$')
0090
0091
0092def sqlIdentifier(obj):
0093    # some db drivers return unicode column names
0094    return isinstance(obj, string_type) and bool(safeSQLRE.search(obj.strip()))
0095
0096
0097def execute(expr, executor):
0098    if hasattr(expr, 'execute'):
0099        return expr.execute(executor)
0100    else:
0101        return expr
0102
0103
0104def _str_or_sqlrepr(expr, db):
0105    if isinstance(expr, string_type):
0106        return expr
0107    return sqlrepr(expr, db)
0108
0109
0110########################################
0111# Expression generation
0112########################################
0113
0114
0115class SQLExpression:
0116    def __add__(self, other):
0117        return SQLOp("+", self, other)
0118
0119    def __radd__(self, other):
0120        return SQLOp("+", other, self)
0121
0122    def __sub__(self, other):
0123        return SQLOp("-", self, other)
0124
0125    def __rsub__(self, other):
0126        return SQLOp("-", other, self)
0127
0128    def __mul__(self, other):
0129        return SQLOp("*", self, other)
0130
0131    def __rmul__(self, other):
0132        return SQLOp("*", other, self)
0133
0134    def __div__(self, other):
0135        return SQLOp("/", self, other)
0136
0137    def __rdiv__(self, other):
0138        return SQLOp("/", other, self)
0139
0140    def __pos__(self):
0141        return SQLPrefix("+", self)
0142
0143    def __neg__(self):
0144        return SQLPrefix("-", self)
0145
0146    def __pow__(self, other):
0147        return SQLConstant("POW")(self, other)
0148
0149    def __rpow__(self, other):
0150        return SQLConstant("POW")(other, self)
0151
0152    def __abs__(self):
0153        return SQLConstant("ABS")(self)
0154
0155    def __mod__(self, other):
0156        return SQLModulo(self, other)
0157
0158    def __rmod__(self, other):
0159        return SQLConstant("MOD")(other, self)
0160
0161    def __lt__(self, other):
0162        return SQLOp("<", self, other)
0163
0164    def __le__(self, other):
0165        return SQLOp("<=", self, other)
0166
0167    def __gt__(self, other):
0168        return SQLOp(">", self, other)
0169
0170    def __ge__(self, other):
0171        return SQLOp(">=", self, other)
0172
0173    def __eq__(self, other):
0174        if other is None:
0175            return ISNULL(self)
0176        else:
0177            return SQLOp("=", self, other)
0178
0179    def __ne__(self, other):
0180        if other is None:
0181            return ISNOTNULL(self)
0182        else:
0183            return SQLOp("<>", self, other)
0184
0185    def __and__(self, other):
0186        return SQLOp("AND", self, other)
0187
0188    def __rand__(self, other):
0189        return SQLOp("AND", other, self)
0190
0191    def __or__(self, other):
0192        return SQLOp("OR", self, other)
0193
0194    def __ror__(self, other):
0195        return SQLOp("OR", other, self)
0196
0197    def __invert__(self):
0198        return SQLPrefix("NOT", self)
0199
0200    def __call__(self, *args):
0201        return SQLCall(self, args)
0202
0203    def __repr__(self):
0204        try:
0205            return self.__sqlrepr__(None)
0206        except AssertionError:
0207            return '<%s %s>' % (
0208                self.__class__.__name__, hex(id(self))[2:])
0209
0210    def __str__(self):
0211        return repr(self)
0212
0213    def __cmp__(self, other):
0214        raise VersionError("Python 2.1+ required")
0215
0216    def __rcmp__(self, other):
0217        raise VersionError("Python 2.1+ required")
0218
0219    def startswith(self, s):
0220        return STARTSWITH(self, s)
0221
0222    def endswith(self, s):
0223        return ENDSWITH(self, s)
0224
0225    def contains(self, s):
0226        return CONTAINSSTRING(self, s)
0227
0228    def components(self):
0229        return []
0230
0231    def tablesUsed(self, db):
0232        return self.tablesUsedSet(db)
0233
0234    def tablesUsedSet(self, db):
0235        tables = set()
0236        for table in self.tablesUsedImmediate():
0237            if hasattr(table, '__sqlrepr__'):
0238                table = sqlrepr(table, db)
0239            tables.add(table)
0240        for component in self.components():
0241            tables.update(tablesUsedSet(component, db))
0242        return tables
0243
0244    def tablesUsedImmediate(self):
0245        return []
0246
0247
0248#######################################
0249# Converter for SQLExpression instances
0250#######################################
0251
0252
0253def SQLExprConverter(value, db):
0254    return value.__sqlrepr__()
0255
0256registerConverter(SQLExpression, SQLExprConverter)
0257
0258
0259def tablesUsedSet(obj, db):
0260    if hasattr(obj, "tablesUsedSet"):
0261        return obj.tablesUsedSet(db)
0262    else:
0263        return {}
0264
0265
0266if PY2:
0267    div = operator.div
0268else:
0269    div = operator.truediv
0270
0271
0272operatorMap = {
0273    "+": operator.add,
0274    "/": div,
0275    "-": operator.sub,
0276    "*": operator.mul,
0277    "<": operator.lt,
0278    "<=": operator.le,
0279    "=": operator.eq,
0280    "!=": operator.ne,
0281    ">=": operator.ge,
0282    ">": operator.gt,
0283    "IN": operator.contains,
0284    "IS": operator.eq,
0285}
0286
0287
0288class SQLOp(SQLExpression):
0289    def __init__(self, op, expr1, expr2):
0290        self.op = op.upper()
0291        self.expr1 = expr1
0292        self.expr2 = expr2
0293
0294    def __sqlrepr__(self, db):
0295        s1 = sqlrepr(self.expr1, db)
0296        s2 = sqlrepr(self.expr2, db)
0297        if s1[0] != '(' and s1 != 'NULL':
0298            s1 = '(' + s1 + ')'
0299        if s2[0] != '(' and s2 != 'NULL':
0300            s2 = '(' + s2 + ')'
0301        return "(%s %s %s)" % (s1, self.op, s2)
0302
0303    def components(self):
0304        return [self.expr1, self.expr2]
0305
0306    def execute(self, executor):
0307        if self.op == "AND":
0308            return execute(self.expr1, executor)                   and execute(self.expr2, executor)
0310        elif self.op == "OR":
0311            return execute(self.expr1, executor)                   or execute(self.expr2, executor)
0313        else:
0314            return operatorMap[self.op.upper()](execute(self.expr1, executor),
0315                                                execute(self.expr2, executor))
0316
0317registerConverter(SQLOp, SQLExprConverter)
0318
0319
0320class SQLModulo(SQLOp):
0321    def __init__(self, expr1, expr2):
0322        SQLOp.__init__(self, '%', expr1, expr2)
0323
0324    def __sqlrepr__(self, db):
0325        if db == 'sqlite':
0326            return SQLOp.__sqlrepr__(self, db)
0327        s1 = sqlrepr(self.expr1, db)
0328        s2 = sqlrepr(self.expr2, db)
0329        return "MOD(%s, %s)" % (s1, s2)
0330
0331registerConverter(SQLModulo, SQLExprConverter)
0332
0333
0334class SQLCall(SQLExpression):
0335    def __init__(self, expr, args):
0336        self.expr = expr
0337        self.args = args
0338
0339    def __sqlrepr__(self, db):
0340        return "%s%s" % (sqlrepr(self.expr, db), sqlrepr(self.args, db))
0341
0342    def components(self):
0343        return [self.expr] + list(self.args)
0344
0345    def execute(self, executor):
0346        raise ValueError("I don't yet know how to locally execute functions")
0347
0348registerConverter(SQLCall, SQLExprConverter)
0349
0350
0351class SQLPrefix(SQLExpression):
0352    def __init__(self, prefix, expr):
0353        self.prefix = prefix
0354        self.expr = expr
0355
0356    def __sqlrepr__(self, db):
0357        return "%s %s" % (self.prefix, sqlrepr(self.expr, db))
0358
0359    def components(self):
0360        return [self.expr]
0361
0362    def execute(self, executor):
0363        prefix = self.prefix
0364        expr = execute(self.expr, executor)
0365        if prefix == "+":
0366            return expr
0367        elif prefix == "-":
0368            return -expr
0369        elif prefix.upper() == "NOT":
0370            return not expr
0371
0372registerConverter(SQLPrefix, SQLExprConverter)
0373
0374
0375class SQLConstant(SQLExpression):
0376    def __init__(self, const):
0377        self.const = const
0378
0379    def __sqlrepr__(self, db):
0380        return self.const
0381
0382    def execute(self, executor):
0383        raise ValueError("I don't yet know how to execute SQL constants")
0384
0385registerConverter(SQLConstant, SQLExprConverter)
0386
0387
0388class SQLTrueClauseClass(SQLExpression):
0389    def __sqlrepr__(self, db):
0390        return "1 = 1"
0391
0392    def execute(self, executor):
0393        return 1
0394
0395SQLTrueClause = SQLTrueClauseClass()
0396
0397registerConverter(SQLTrueClauseClass, SQLExprConverter)
0398
0399########################################
0400# Namespaces
0401########################################
0402
0403
0404class Field(SQLExpression):
0405    def __init__(self, tableName, fieldName):
0406        self.tableName = tableName
0407        self.fieldName = fieldName
0408
0409    def __sqlrepr__(self, db):
0410        return self.tableName + "." + self.fieldName
0411
0412    def tablesUsedImmediate(self):
0413        return [self.tableName]
0414
0415    def execute(self, executor):
0416        return executor.field(self.tableName, self.fieldName)
0417
0418
0419class SQLObjectField(Field):
0420    def __init__(self, tableName, fieldName, original, soClass, column):
0421        Field.__init__(self, tableName, fieldName)
0422        self.original = original
0423        self.soClass = soClass
0424        self.column = column
0425
0426    def _from_python(self, value):
0427        column = self.column
0428        if not isinstance(value, SQLExpression) and                   column and column.from_python:
0430            value = column.from_python(value, SQLObjectState(self.soClass))
0431        return value
0432
0433    def __eq__(self, other):
0434        if other is None:
0435            return ISNULL(self)
0436        other = self._from_python(other)
0437        return SQLOp('=', self, other)
0438
0439    def __ne__(self, other):
0440        if other is None:
0441            return ISNOTNULL(self)
0442        other = self._from_python(other)
0443        return SQLOp('<>', self, other)
0444
0445    def startswith(self, s):
0446        s = self._from_python(s)
0447        return STARTSWITH(self, s)
0448
0449    def endswith(self, s):
0450        s = self._from_python(s)
0451        return ENDSWITH(self, s)
0452
0453    def contains(self, s):
0454        s = self._from_python(s)
0455        return CONTAINSSTRING(self, s)
0456
0457registerConverter(SQLObjectField, SQLExprConverter)
0458
0459
0460class Table(SQLExpression):
0461    FieldClass = Field
0462
0463    def __init__(self, tableName):
0464        self.tableName = tableName
0465
0466    def __getattr__(self, attr):
0467        if attr.startswith('__'):
0468            raise AttributeError
0469        return self.FieldClass(self.tableName, attr)
0470
0471    def __sqlrepr__(self, db):
0472        return _str_or_sqlrepr(self.tableName, db)
0473
0474    def execute(self, executor):
0475        raise ValueError("Tables don't have values")
0476
0477
0478class SQLObjectTable(Table):
0479    FieldClass = SQLObjectField
0480
0481    def __init__(self, soClass):
0482        self.soClass = soClass
0483        assert soClass.sqlmeta.table, (
0484            "Bad table name in class %r: %r"
0485            % (soClass, soClass.sqlmeta.table))
0486        Table.__init__(self, soClass.sqlmeta.table)
0487
0488    def __getattr__(self, attr):
0489        if attr.startswith('__'):
0490            raise AttributeError
0491        if attr == 'id':
0492            return self._getattrFromID(attr)
0493        elif attr in self.soClass.sqlmeta.columns:
0494            column = self.soClass.sqlmeta.columns[attr]
0495            return self._getattrFromColumn(column, attr)
0496        elif attr + 'ID' in               [k for (k, v) in self.soClass.sqlmeta.columns.items()
0498                if v.foreignKey]:
0499            attr += 'ID'
0500            column = self.soClass.sqlmeta.columns[attr]
0501            return self._getattrFromColumn(column, attr)
0502        else:
0503            raise AttributeError(
0504                "%s instance has no attribute '%s'" % (self.soClass.__name__,
0505                                                       attr))
0506
0507    def _getattrFromID(self, attr):
0508        return self.FieldClass(self.tableName, self.soClass.sqlmeta.idName,
0509                               attr, self.soClass, None)
0510
0511    def _getattrFromColumn(self, column, attr):
0512        return self.FieldClass(self.tableName, column.dbName, attr,
0513                               self.soClass, column)
0514
0515
0516class SQLObjectTableWithJoins(SQLObjectTable):
0517
0518    def __getattr__(self, attr):
0519        if attr + 'ID' in               [k for (k, v) in self.soClass.sqlmeta.columns.items()
0521                if v.foreignKey]:
0522            column = self.soClass.sqlmeta.columns[attr + 'ID']
0523            return self._getattrFromForeignKey(column, attr)
0524        elif attr in [x.joinMethodName for x in self.soClass.sqlmeta.joins]:
0525            join = [x for x in self.soClass.sqlmeta.joins
0526                    if x.joinMethodName == attr][0]
0527            return self._getattrFromJoin(join, attr)
0528        else:
0529            return SQLObjectTable.__getattr__(self, attr)
0530
0531    def _getattrFromForeignKey(self, column, attr):
0532        ret = getattr(self, column.name) ==               getattr(self.soClass, '_SO_class_' + column.foreignKey).q.id
0534        return ret
0535
0536    def _getattrFromJoin(self, join, attr):
0537        if hasattr(join, 'otherColumn'):
0538            return AND(
0539                join.otherClass.q.id == Field(join.intermediateTable,
0540                                              join.otherColumn),
0541                Field(join.intermediateTable,
0542                      join.joinColumn) == self.soClass.q.id)
0543        else:
0544            return getattr(join.otherClass.q, join.joinColumn) ==                   self.soClass.q.id
0546
0547
0548class TableSpace:
0549    TableClass = Table
0550
0551    def __getattr__(self, attr):
0552        if attr.startswith('__'):
0553            raise AttributeError
0554        return self.TableClass(attr)
0555
0556
0557class ConstantSpace:
0558    def __getattr__(self, attr):
0559        if attr.startswith('__'):
0560            raise AttributeError
0561        return SQLConstant(attr)
0562
0563
0564########################################
0565# Table aliases
0566########################################
0567
0568class AliasField(Field):
0569    def __init__(self, tableName, fieldName, alias, aliasTable):
0570        Field.__init__(self, tableName, fieldName)
0571        self.alias = alias
0572        self.aliasTable = aliasTable
0573
0574    def __sqlrepr__(self, db):
0575        fieldName = self.fieldName
0576        if isinstance(fieldName, SQLExpression):
0577            fieldName = sqlrepr(fieldName, db)
0578        return self.alias + "." + fieldName
0579
0580    def tablesUsedImmediate(self):
0581        return [self.aliasTable]
0582
0583
0584class AliasTable(Table):
0585    as_string = ''  # set it to "AS" if your database requires it
0586    FieldClass = AliasField
0587
0588    _alias_lock = threading.Lock()
0589    _alias_counter = 0
0590
0591    def __init__(self, table, alias=None):
0592        if hasattr(table, "sqlmeta"):
0593            tableName = SQLConstant(table.sqlmeta.table)
0594        elif isinstance(table, (Select, Union)):
0595            assert alias is not None,                   "Alias name cannot be constructed from Select instances, "                   "please provide an 'alias' keyword."
0598            tableName = Subquery('', table)
0599            table = None
0600        else:
0601            tableName = SQLConstant(table)
0602            table = None
0603        Table.__init__(self, tableName)
0604        self.table = table
0605        if alias is None:
0606            self._alias_lock.acquire()
0607            try:
0608                AliasTable._alias_counter += 1
0609                alias = "%s_alias%d" % (tableName, AliasTable._alias_counter)
0610            finally:
0611                self._alias_lock.release()
0612        self.alias = alias
0613
0614    def __getattr__(self, attr):
0615        if attr.startswith('__'):
0616            raise AttributeError
0617        if self.table:
0618            attr = getattr(self.table.q, attr).fieldName
0619        return self.FieldClass(self.tableName, attr, self.alias, self)
0620
0621    def __sqlrepr__(self, db):
0622        return "%s %s %s" % (sqlrepr(self.tableName, db), self.as_string,
0623                             self.alias)
0624
0625
0626class Alias(SQLExpression):
0627    def __init__(self, table, alias=None):
0628        self.q = AliasTable(table, alias)
0629
0630    def __sqlrepr__(self, db):
0631        return sqlrepr(self.q, db)
0632
0633    def components(self):
0634        return [self.q]
0635
0636
0637class Union(SQLExpression):
0638    def __init__(self, *tables):
0639        tabs = []
0640        for t in tables:
0641            if not isinstance(t, SQLExpression) and hasattr(t, 'sqlmeta'):
0642                t = t.sqlmeta.table
0643                if isinstance(t, Alias):
0644                    t = t.q
0645                if isinstance(t, Table):
0646                    t = t.tableName
0647                if not isinstance(t, SQLExpression):
0648                    t = SQLConstant(t)
0649            tabs.append(t)
0650        self.tables = tabs
0651
0652    def __sqlrepr__(self, db):
0653        return " UNION ".join([str(sqlrepr(t, db)) for t in self.tables])
0654
0655########################################
0656# SQL Statements
0657########################################
0658
0659
0660class Select(SQLExpression):
0661    def __init__(self, items=NoDefault, where=NoDefault, groupBy=NoDefault,
0662                 having=NoDefault, orderBy=NoDefault, limit=NoDefault,
0663                 join=NoDefault, lazyColumns=False, distinct=False,
0664                 start=0, end=None, reversed=False, forUpdate=False,
0665                 clause=NoDefault, staticTables=NoDefault,
0666                 distinctOn=NoDefault):
0667        self.ops = {}
0668        if not isinstance(items, (list, tuple, types.GeneratorType)):
0669            items = [items]
0670        if clause is NoDefault and where is not NoDefault:
0671            clause = where
0672        if staticTables is NoDefault:
0673            staticTables = []
0674        self.ops['items'] = items
0675        self.ops['clause'] = clause
0676        self.ops['groupBy'] = groupBy
0677        self.ops['having'] = having
0678        self.ops['orderBy'] = orderBy
0679        self.ops['limit'] = limit
0680        self.ops['join'] = join
0681        self.ops['lazyColumns'] = lazyColumns
0682        self.ops['distinct'] = distinct
0683        self.ops['distinctOn'] = distinctOn
0684        self.ops['start'] = start
0685        self.ops['end'] = end
0686        self.ops['reversed'] = reversed
0687        self.ops['forUpdate'] = forUpdate
0688        self.ops['staticTables'] = staticTables
0689
0690    def clone(self, **newOps):
0691        ops = self.ops.copy()
0692        ops.update(newOps)
0693        return self.__class__(**ops)
0694
0695    def newItems(self, items):
0696        return self.clone(items=items)
0697
0698    def newClause(self, new_clause):
0699        return self.clone(clause=new_clause)
0700
0701    def orderBy(self, orderBy):
0702        return self.clone(orderBy=orderBy)
0703
0704    def unlimited(self):
0705        return self.clone(limit=NoDefault, start=0, end=None)
0706
0707    def limit(self, limit):
0708        self.clone(limit=limit)
0709
0710    def lazyColumns(self, value):
0711        return self.clone(lazyColumns=value)
0712
0713    def reversed(self):
0714        return self.clone(reversed=not self.ops.get('reversed', False))
0715
0716    def distinct(self):
0717        return self.clone(distinct=True)
0718
0719    def filter(self, filter_clause):
0720        if filter_clause is None:
0721            # None doesn't filter anything, it's just a no-op:
0722            return self
0723        clause = self.ops['clause']
0724        if isinstance(clause, string_type):
0725            clause = SQLConstant('(%s)' % clause)
0726        return self.newClause(AND(clause, filter_clause))
0727
0728    def __sqlrepr__(self, db):
0729
0730        select = "SELECT"
0731        if self.ops['distinct']:
0732            select += " DISTINCT"
0733            if self.ops['distinctOn'] is not NoDefault:
0734                select += " ON(%s)" % _str_or_sqlrepr(
0735                    self.ops['distinctOn'], db)
0736        if not self.ops['lazyColumns']:
0737            select += " %s" % ", ".join(
0738                [str(_str_or_sqlrepr(v, db)) for v in self.ops['items']])
0739        else:
0740            select += " %s" % _str_or_sqlrepr(self.ops['items'][0], db)
0741
0742        join = []
0743        join_str = ''
0744        if self.ops['join'] is not NoDefault and self.ops['join'] is not None:
0745            _join = self.ops['join']
0746            if isinstance(_join, str):
0747                join_str = " " + _join
0748            elif isinstance(_join, SQLJoin):
0749                join.append(_join)
0750            else:
0751                join.extend(_join)
0752        tables = set()
0753        for x in self.ops['staticTables']:
0754            if isinstance(x, SQLExpression):
0755                x = sqlrepr(x, db)
0756            tables.add(x)
0757        things = list(self.ops['items']) + join
0758        if self.ops['clause'] is not NoDefault:
0759            things.append(self.ops['clause'])
0760        for thing in things:
0761            if isinstance(thing, SQLExpression):
0762                tables.update(tablesUsedSet(thing, db))
0763        for j in join:
0764            t1 = _str_or_sqlrepr(j.table1, db)
0765            if t1 in tables:
0766                tables.remove(t1)
0767            t2 = _str_or_sqlrepr(j.table2, db)
0768            if t2 in tables:
0769                tables.remove(t2)
0770        if tables:
0771            select += " FROM %s" % ", ".join(sorted(tables))
0772        elif join:
0773            select += " FROM"
0774        tablesYet = tables
0775        for j in join:
0776            if tablesYet and j.table1:
0777                sep = ", "
0778            else:
0779                sep = " "
0780            select += sep + sqlrepr(j, db)
0781            tablesYet = True
0782
0783        if join_str:
0784            select += join_str
0785
0786        if self.ops['clause'] is not NoDefault:
0787            select += " WHERE %s" % _str_or_sqlrepr(self.ops['clause'], db)
0788        if self.ops['groupBy'] is not NoDefault:
0789            groupBy = _str_or_sqlrepr(self.ops['groupBy'], db)
0790            if isinstance(self.ops['groupBy'], (list, tuple)):
0791                groupBy = groupBy[1:-1]  # Remove parens
0792            select += " GROUP BY %s" % groupBy
0793        if self.ops['having'] is not NoDefault:
0794            select += " HAVING %s" % _str_or_sqlrepr(self.ops['having'], db)
0795        if self.ops['orderBy'] is not NoDefault and              self.ops['orderBy'] is not None:
0797            orderBy = self.ops['orderBy']
0798            if self.ops['reversed']:
0799                reverser = DESC
0800            else:
0801                def reverser(x):
0802                    return x
0803            if isinstance(orderBy, (list, tuple)):
0804                select += " ORDER BY %s" % ", ".join(
0805                    [_str_or_sqlrepr(reverser(_x), db) for _x in orderBy])
0806            else:
0807                select += " ORDER BY %s" % _str_or_sqlrepr(
0808                    reverser(orderBy), db)
0809        start, end = self.ops['start'], self.ops['end']
0810        if self.ops['limit'] is not NoDefault:
0811            end = start + self.ops['limit']
0812        if start or end:
0813            from .dbconnection import dbConnectionForScheme
0814            select = dbConnectionForScheme(db)._queryAddLimitOffset(select,
0815                                                                    start, end)
0816        if self.ops['forUpdate']:
0817            select += " FOR UPDATE"
0818        return select
0819
0820registerConverter(Select, SQLExprConverter)
0821
0822
0823class Insert(SQLExpression):
0824    def __init__(self, table, valueList=None, values=None, template=NoDefault):
0825        self.template = template
0826        self.table = table
0827        if valueList:
0828            if values:
0829                raise TypeError("You may only give valueList *or* values")
0830            self.valueList = valueList
0831        else:
0832            self.valueList = [values]
0833
0834    def __sqlrepr__(self, db):
0835        if not self.valueList:
0836            return ''
0837        insert = "INSERT INTO %s" % self.table
0838        allowNonDict = True
0839        template = self.template
0840        if (template is NoDefault) and isinstance(self.valueList[0], dict):
0841            template = list(sorted(self.valueList[0].keys()))
0842            allowNonDict = False
0843        if template is not NoDefault:
0844            insert += " (%s)" % ", ".join(template)
0845        insert += " VALUES "
0846        listToJoin = []
0847        listToJoin_app = listToJoin.append
0848        for value in self.valueList:
0849            if isinstance(value, dict):
0850                if template is NoDefault:
0851                    raise TypeError(
0852                        "You can't mix non-dictionaries with dictionaries "
0853                        "in an INSERT if you don't provide a template (%s)" %
0854                        repr(value))
0855                value = dictToList(template, value)
0856            elif not allowNonDict:
0857                raise TypeError(
0858                    "You can't mix non-dictionaries with dictionaries "
0859                    "in an INSERT if you don't provide a template (%s)" %
0860                    repr(value))
0861            listToJoin_app("(%s)" % ", ".join([sqlrepr(v, db) for v in value]))
0862        insert = "%s%s" % (insert, ", ".join(listToJoin))
0863        return insert
0864
0865registerConverter(Insert, SQLExprConverter)
0866
0867
0868def dictToList(template, dict):
0869    list = []
0870    for key in template:
0871        list.append(dict[key])
0872    if len(dict.keys()) > len(template):
0873        raise TypeError(
0874            "Extra entries in dictionary that aren't asked for in template "
0875            "(template=%s, dict=%s)" % (repr(template), repr(dict)))
0876    return list
0877
0878
0879class Update(SQLExpression):
0880    def __init__(self, table, values, template=NoDefault, where=NoDefault):
0881        self.table = table
0882        self.values = values
0883        self.template = template
0884        self.whereClause = where
0885
0886    def __sqlrepr__(self, db):
0887        update = "%s %s" % (self.sqlName(), self.table)
0888        update += " SET"
0889        first = True
0890        if self.template is not NoDefault:
0891            for i in range(len(self.template)):
0892                if first:
0893                    first = False
0894                else:
0895                    update += ","
0896                update += " %s=%s" % (self.template[i],
0897                                      sqlrepr(self.values[i], db))
0898        else:
0899            for key, value in sorted(self.values.items()):
0900                if first:
0901                    first = False
0902                else:
0903                    update += ","
0904                update += " %s=%s" % (key, sqlrepr(value, db))
0905        if self.whereClause is not NoDefault:
0906            update += " WHERE %s" % _str_or_sqlrepr(self.whereClause, db)
0907        return update
0908
0909    def sqlName(self):
0910        return "UPDATE"
0911
0912registerConverter(Update, SQLExprConverter)
0913
0914
0915class Delete(SQLExpression):
0916    """To be safe, this will signal an error if there is no where clause,
0917    unless you pass in where=None to the constructor."""
0918    def __init__(self, table, where=NoDefault):
0919        self.table = table
0920        if where is NoDefault:
0921            raise TypeError(
0922                "You must give a where clause or pass in None "
0923                "to indicate no where clause")
0924        self.whereClause = where
0925
0926    def __sqlrepr__(self, db):
0927        whereClause = self.whereClause
0928        if whereClause is None:
0929            return "DELETE FROM %s" % self.table
0930        whereClause = _str_or_sqlrepr(whereClause, db)
0931        return "DELETE FROM %s WHERE %s" % (self.table, whereClause)
0932
0933registerConverter(Delete, SQLExprConverter)
0934
0935
0936class Replace(Update):
0937    def sqlName(self):
0938        return "REPLACE"
0939
0940registerConverter(Replace, SQLExprConverter)
0941
0942########################################
0943# SQL Builtins
0944########################################
0945
0946
0947class DESC(SQLExpression):
0948
0949    def __init__(self, expr):
0950        self.expr = expr
0951
0952    def __sqlrepr__(self, db):
0953        if isinstance(self.expr, DESC):
0954            return sqlrepr(self.expr.expr, db)
0955        return '%s DESC' % sqlrepr(self.expr, db)
0956
0957
0958def AND(*ops):
0959    if not ops:
0960        return None
0961    op1 = ops[0]
0962    ops = ops[1:]
0963    if ops:
0964        return SQLOp("AND", op1, AND(*ops))
0965    else:
0966        return op1
0967
0968
0969def OR(*ops):
0970    if not ops:
0971        return None
0972    op1 = ops[0]
0973    ops = ops[1:]
0974    if ops:
0975        return SQLOp("OR", op1, OR(*ops))
0976    else:
0977        return op1
0978
0979
0980def NOT(op):
0981    return SQLPrefix("NOT", op)
0982
0983
0984def _IN(item, list):
0985    return SQLOp("IN", item, list)
0986
0987
0988def IN(item, list):
0989    from .sresults import SelectResults  # Import here to avoid circular import
0990    if isinstance(list, SelectResults):
0991        query = list.queryForSelect()
0992        query.ops['items'] = [list.sourceClass.q.id]
0993        list = query
0994    if isinstance(list, Select):
0995        return INSubquery(item, list)
0996    else:
0997        return _IN(item, list)
0998
0999
1000def NOTIN(item, list):
1001    if isinstance(list, Select):
1002        return NOTINSubquery(item, list)
1003    else:
1004        return NOT(_IN(item, list))
1005
1006
1007def STARTSWITH(expr, pattern):
1008    return LIKE(expr, _LikeQuoted(pattern) + '%', escape='\\')
1009
1010
1011def ENDSWITH(expr, pattern):
1012    return LIKE(expr, '%' + _LikeQuoted(pattern), escape='\\')
1013
1014
1015def CONTAINSSTRING(expr, pattern):
1016    return LIKE(expr, '%' + _LikeQuoted(pattern) + '%', escape='\\')
1017
1018
1019def ISNULL(expr):
1020    return SQLOp("IS", expr, None)
1021
1022
1023def ISNOTNULL(expr):
1024    return SQLOp("IS NOT", expr, None)
1025
1026
1027class ColumnAS(SQLOp):
1028    ''' Just like SQLOp('AS', expr, name) except without the parentheses '''
1029    def __init__(self, expr, name):
1030        if isinstance(name, string_type):
1031            name = SQLConstant(name)
1032        SQLOp.__init__(self, 'AS', expr, name)
1033
1034    def __sqlrepr__(self, db):
1035        return "%s %s %s" % (sqlrepr(self.expr1, db), self.op,
1036                             sqlrepr(self.expr2, db))
1037
1038
1039class _LikeQuoted:
1040    # It assumes prefix and postfix are strings; usually just a percent sign.
1041
1042    # @@: I'm not sure what the quoting rules really are for all the
1043    # databases
1044
1045    def __init__(self, expr):
1046        self.expr = expr
1047        self.prefix = ''
1048        self.postfix = ''
1049
1050    def __radd__(self, s):
1051        self.prefix = s + self.prefix
1052        return self
1053
1054    def __add__(self, s):
1055        self.postfix += s
1056        return self
1057
1058    def __sqlrepr__(self, db):
1059        s = self.expr
1060        if isinstance(s, SQLExpression):
1061            values = []
1062            if self.prefix:
1063                values.append(quote_str(self.prefix, db))
1064            s = _quote_like_special(sqlrepr(s, db), db)
1065            values.append(s)
1066            if self.postfix:
1067                values.append(quote_str(self.postfix, db))
1068            if db == "mysql":
1069                return "CONCAT(%s)" % ", ".join(values)
1070            else:
1071                return " || ".join(values)
1072        elif isinstance(s, string_type):
1073            s = _quote_like_special(unquote_str(sqlrepr(s, db)), db)
1074            return quote_str("%s%s%s" % (self.prefix, s, self.postfix), db)
1075        else:
1076            raise TypeError(
1077                "expected str, unicode or SQLExpression, got %s" % type(s))
1078
1079
1080def _quote_like_special(s, db):
1081    if db in ('postgres', 'rdbhost'):
1082        escape = r'\\'
1083    else:
1084        escape = '\\'
1085    s = s.replace('\\', r'\\').          replace('%', escape + '%').          replace('_', escape + '_')
1088    return s
1089
1090
1091class CONCAT(SQLExpression):
1092    def __init__(self, *expressions):
1093        self.expressions = expressions
1094
1095    def __sqlrepr__(self, db):
1096        values = [sqlrepr(expr, db) for expr in self.expressions]
1097        if db == "mysql":
1098            return "CONCAT(%s)" % ", ".join(values)
1099        else:
1100            return " || ".join(values)
1101
1102########################################
1103# SQL JOINs
1104########################################
1105
1106
1107class SQLJoin(SQLExpression):
1108    def __init__(self, table1, table2, op=','):
1109        if hasattr(table1, 'sqlmeta'):
1110            table1 = table1.sqlmeta.table
1111        if hasattr(table2, 'sqlmeta'):
1112            table2 = table2.sqlmeta.table
1113        if isinstance(table1, str):
1114            table1 = SQLConstant(table1)
1115        if isinstance(table2, str):
1116            table2 = SQLConstant(table2)
1117        self.table1 = table1
1118        self.table2 = table2
1119        self.op = op
1120
1121    def __sqlrepr__(self, db):
1122        if self.table1:
1123            return "%s%s %s" % (sqlrepr(self.table1, db), self.op,
1124                                sqlrepr(self.table2, db))
1125        else:
1126            return "%s %s" % (self.op, sqlrepr(self.table2, db))
1127
1128registerConverter(SQLJoin, SQLExprConverter)
1129
1130
1131def JOIN(table1, table2):
1132    return SQLJoin(table1, table2, " JOIN")
1133
1134
1135def INNERJOIN(table1, table2):
1136    return SQLJoin(table1, table2, " INNER JOIN")
1137
1138
1139def CROSSJOIN(table1, table2):
1140    return SQLJoin(table1, table2, " CROSS JOIN")
1141
1142
1143def STRAIGHTJOIN(table1, table2):
1144    return SQLJoin(table1, table2, " STRAIGHT JOIN")
1145
1146
1147def LEFTJOIN(table1, table2):
1148    return SQLJoin(table1, table2, " LEFT JOIN")
1149
1150
1151def LEFTOUTERJOIN(table1, table2):
1152    return SQLJoin(table1, table2, " LEFT OUTER JOIN")
1153
1154
1155def NATURALJOIN(table1, table2):
1156    return SQLJoin(table1, table2, " NATURAL JOIN")
1157
1158
1159def NATURALLEFTJOIN(table1, table2):
1160    return SQLJoin(table1, table2, " NATURAL LEFT JOIN")
1161
1162
1163def NATURALLEFTOUTERJOIN(table1, table2):
1164    return SQLJoin(table1, table2, " NATURAL LEFT OUTER JOIN")
1165
1166
1167def RIGHTJOIN(table1, table2):
1168    return SQLJoin(table1, table2, " RIGHT JOIN")
1169
1170
1171def RIGHTOUTERJOIN(table1, table2):
1172    return SQLJoin(table1, table2, " RIGHT OUTER JOIN")
1173
1174
1175def NATURALRIGHTJOIN(table1, table2):
1176    return SQLJoin(table1, table2, " NATURAL RIGHT JOIN")
1177
1178
1179def NATURALRIGHTOUTERJOIN(table1, table2):
1180    return SQLJoin(table1, table2, " NATURAL RIGHT OUTER JOIN")
1181
1182
1183def FULLJOIN(table1, table2):
1184    return SQLJoin(table1, table2, " FULL JOIN")
1185
1186
1187def FULLOUTERJOIN(table1, table2):
1188    return SQLJoin(table1, table2, " FULL OUTER JOIN")
1189
1190
1191def NATURALFULLJOIN(table1, table2):
1192    return SQLJoin(table1, table2, " NATURAL FULL JOIN")
1193
1194
1195def NATURALFULLOUTERJOIN(table1, table2):
1196    return SQLJoin(table1, table2, " NATURAL FULL OUTER JOIN")
1197
1198
1199class SQLJoinConditional(SQLJoin):
1200    """Conditional JOIN"""
1201    def __init__(self, table1, table2, op,
1202                 on_condition=None, using_columns=None):
1203        """For condition you must give on_condition or using_columns
1204        but not both
1205
1206        on_condition can be a string or SQLExpression, for example
1207            Table1.q.col1 == Table2.q.col2
1208        using_columns can be a string or a list of columns, e.g.
1209            (Table1.q.col1, Table2.q.col2)
1210        """
1211        if not on_condition and not using_columns:
1212            raise TypeError("You must give ON condition or USING columns")
1213        if on_condition and using_columns:
1214            raise TypeError(
1215                "You must give ON condition or USING columns but not both")
1216        SQLJoin.__init__(self, table1, table2, op)
1217        self.on_condition = on_condition
1218        self.using_columns = using_columns
1219
1220    def __sqlrepr__(self, db):
1221        if self.on_condition:
1222            on_condition = self.on_condition
1223            if hasattr(on_condition, "__sqlrepr__"):
1224                on_condition = sqlrepr(on_condition, db)
1225            join = "%s %s ON %s" % (self.op, sqlrepr(self.table2, db),
1226                                    on_condition)
1227            if self.table1:
1228                join = "%s %s" % (sqlrepr(self.table1, db), join)
1229            return join
1230        elif self.using_columns:
1231            using_columns = []
1232            for col in self.using_columns:
1233                if hasattr(col, "__sqlrepr__"):
1234                    col = sqlrepr(col, db)
1235                using_columns.append(col)
1236            using_columns = ", ".join(using_columns)
1237            join = "%s %s USING (%s)" % (self.op, sqlrepr(self.table2, db),
1238                                         using_columns)
1239            if self.table1:
1240                join = "%s %s" % (sqlrepr(self.table1, db), join)
1241            return join
1242        else:
1243            RuntimeError, "Impossible error"
1244
1245registerConverter(SQLJoinConditional, SQLExprConverter)
1246
1247
1248def INNERJOINConditional(table1, table2,
1249                         on_condition=None, using_columns=None):
1250    return SQLJoinConditional(table1, table2, "INNER JOIN",
1251                              on_condition, using_columns)
1252
1253
1254def LEFTJOINConditional(table1, table2, on_condition=None, using_columns=None):
1255    return SQLJoinConditional(table1, table2, "LEFT JOIN",
1256                              on_condition, using_columns)
1257
1258
1259def LEFTOUTERJOINConditional(table1, table2,
1260                             on_condition=None, using_columns=None):
1261    return SQLJoinConditional(table1, table2, "LEFT OUTER JOIN",
1262                              on_condition, using_columns)
1263
1264
1265def RIGHTJOINConditional(table1, table2,
1266                         on_condition=None, using_columns=None):
1267    return SQLJoinConditional(table1, table2, "RIGHT JOIN",
1268                              on_condition, using_columns)
1269
1270
1271def RIGHTOUTERJOINConditional(table1, table2,
1272                              on_condition=None, using_columns=None):
1273    return SQLJoinConditional(table1, table2, "RIGHT OUTER JOIN",
1274                              on_condition, using_columns)
1275
1276
1277def FULLJOINConditional(table1, table2, on_condition=None, using_columns=None):
1278    return SQLJoinConditional(table1, table2, "FULL JOIN",
1279                              on_condition, using_columns)
1280
1281
1282def FULLOUTERJOINConditional(table1, table2,
1283                             on_condition=None, using_columns=None):
1284    return SQLJoinConditional(table1, table2, "FULL OUTER JOIN",
1285                              on_condition, using_columns)
1286
1287
1288class SQLJoinOn(SQLJoinConditional):
1289    """Conditional JOIN ON"""
1290    def __init__(self, table1, table2, op, on_condition):
1291        SQLJoinConditional.__init__(self, table1, table2, op, on_condition)
1292
1293registerConverter(SQLJoinOn, SQLExprConverter)
1294
1295
1296class SQLJoinUsing(SQLJoinConditional):
1297    """Conditional JOIN USING"""
1298    def __init__(self, table1, table2, op, using_columns):
1299        SQLJoinConditional.__init__(self, table1, table2,
1300                                    op, None, using_columns)
1301
1302registerConverter(SQLJoinUsing, SQLExprConverter)
1303
1304
1305def INNERJOINOn(table1, table2, on_condition):
1306    return SQLJoinOn(table1, table2, "INNER JOIN", on_condition)
1307
1308
1309def LEFTJOINOn(table1, table2, on_condition):
1310    return SQLJoinOn(table1, table2, "LEFT JOIN", on_condition)
1311
1312
1313def LEFTOUTERJOINOn(table1, table2, on_condition):
1314    return SQLJoinOn(table1, table2, "LEFT OUTER JOIN", on_condition)
1315
1316
1317def RIGHTJOINOn(table1, table2, on_condition):
1318    return SQLJoinOn(table1, table2, "RIGHT JOIN", on_condition)
1319
1320
1321def RIGHTOUTERJOINOn(table1, table2, on_condition):
1322    return SQLJoinOn(table1, table2, "RIGHT OUTER JOIN", on_condition)
1323
1324
1325def FULLJOINOn(table1, table2, on_condition):
1326    return SQLJoinOn(table1, table2, "FULL JOIN", on_condition)
1327
1328
1329def FULLOUTERJOINOn(table1, table2, on_condition):
1330    return SQLJoinOn(table1, table2, "FULL OUTER JOIN", on_condition)
1331
1332
1333def INNERJOINUsing(table1, table2, using_columns):
1334    return SQLJoinUsing(table1, table2, "INNER JOIN", using_columns)
1335
1336
1337def LEFTJOINUsing(table1, table2, using_columns):
1338    return SQLJoinUsing(table1, table2, "LEFT JOIN", using_columns)
1339
1340
1341def LEFTOUTERJOINUsing(table1, table2, using_columns):
1342    return SQLJoinUsing(table1, table2, "LEFT OUTER JOIN", using_columns)
1343
1344
1345def RIGHTJOINUsing(table1, table2, using_columns):
1346    return SQLJoinUsing(table1, table2, "RIGHT JOIN", using_columns)
1347
1348
1349def RIGHTOUTERJOINUsing(table1, table2, using_columns):
1350    return SQLJoinUsing(table1, table2, "RIGHT OUTER JOIN", using_columns)
1351
1352
1353def FULLJOINUsing(table1, table2, using_columns):
1354    return SQLJoinUsing(table1, table2, "FULL JOIN", using_columns)
1355
1356
1357def FULLOUTERJOINUsing(table1, table2, using_columns):
1358    return SQLJoinUsing(table1, table2, "FULL OUTER JOIN", using_columns)
1359
1360
1361########################################
1362# Subqueries (subselects)
1363########################################
1364
1365class OuterField(SQLObjectField):
1366    def tablesUsedImmediate(self):
1367        return []
1368
1369
1370class OuterTable(SQLObjectTable):
1371    FieldClass = OuterField
1372
1373
1374class Outer:
1375    def __init__(self, table):
1376        self.q = OuterTable(table)
1377
1378
1379class LIKE(SQLExpression):
1380    op = "LIKE"
1381
1382    def __init__(self, expr, string, escape=None):
1383        self.expr = expr
1384        self.string = string
1385        self.escape = escape
1386
1387    def __sqlrepr__(self, db):
1388        escape = self.escape
1389        like = "%s %s (%s)" % (sqlrepr(self.expr, db),
1390                               self.op, sqlrepr(self.string, db))
1391        if escape is None:
1392            return "(%s)" % like
1393        else:
1394            return "(%s ESCAPE %s)" % (like, sqlrepr(escape, db))
1395
1396    def components(self):
1397        return [self.expr, self.string]
1398
1399    def execute(self, executor):
1400        if not hasattr(self, '_regex'):
1401            # @@: Crude, not entirely accurate
1402            dest = self.string
1403            dest = dest.replace("%%", "\001")
1404            dest = dest.replace("*", "\002")
1405            dest = dest.replace("%", "*")
1406            dest = dest.replace("\001", "%")
1407            dest = dest.replace("\002", "[*]")
1408            self._regex = re.compile(fnmatch.translate(dest), re.I)
1409        return self._regex.search(execute(self.expr, executor))
1410
1411
1412class RLIKE(LIKE):
1413    op = "RLIKE"
1414
1415    op_db = {
1416        'firebird': 'RLIKE',
1417        'maxdb': 'RLIKE',
1418        'mysql': 'RLIKE',
1419        'postgres': '~',
1420        'rdbhost': '~',
1421        'sqlite': 'REGEXP'
1422    }
1423
1424    def _get_op(self, db):
1425        return self.op_db.get(db, 'LIKE')
1426
1427    def __sqlrepr__(self, db):
1428        return "(%s %s (%s))" % (
1429            sqlrepr(self.expr, db), self._get_op(db), sqlrepr(self.string, db)
1430        )
1431
1432    def execute(self, executor):
1433        self.op = self._get_op(self.db)
1434        return LIKE.execute(self, executor)
1435
1436
1437class INSubquery(SQLExpression):
1438    op = "IN"
1439
1440    def __init__(self, item, subquery):
1441        self.item = item
1442        self.subquery = subquery
1443
1444    def components(self):
1445        return [self.item]
1446
1447    def __sqlrepr__(self, db):
1448        return "%s %s (%s)" % (sqlrepr(self.item, db),
1449                               self.op, sqlrepr(self.subquery, db))
1450
1451
1452class NOTINSubquery(INSubquery):
1453    op = "NOT IN"
1454
1455
1456class Subquery(SQLExpression):
1457    def __init__(self, op, subquery):
1458        self.op = op
1459        self.subquery = subquery
1460
1461    def __sqlrepr__(self, db):
1462        return "%s (%s)" % (self.op, sqlrepr(self.subquery, db))
1463
1464
1465def EXISTS(subquery):
1466    return Subquery("EXISTS", subquery)
1467
1468
1469def NOTEXISTS(subquery):
1470    return Subquery("NOT EXISTS", subquery)
1471
1472
1473def SOME(subquery):
1474    return Subquery("SOME", subquery)
1475
1476
1477def ANY(subquery):
1478    return Subquery("ANY", subquery)
1479
1480
1481def ALL(subquery):
1482    return Subquery("ALL", subquery)
1483
1484
1485####
1486
1487
1488class ImportProxyField(SQLObjectField):
1489    def tablesUsedImmediate(self):
1490        return [str(self.tableName)]
1491
1492
1493class ImportProxy(SQLExpression):
1494    '''Class to be used in column definitions that rely on other tables that might
1495        not yet be in a classregistry.
1496    '''
1497    FieldClass = ImportProxyField
1498
1499    def __init__(self, clsName, registry=None):
1500        self.tableName = _DelayClass(self, clsName)
1501        self.sqlmeta = _Delay_proxy(table=_DelayClass(self, clsName))
1502        self.q = self
1503        self.soClass = None
1504        classregistry.registry(registry).addClassCallback(
1505            clsName, lambda foreign, me: setattr(me, 'soClass', foreign), self)
1506
1507    def __nonzero__(self):
1508        return True
1509
1510    def __getattr__(self, attr):
1511        if self.soClass is None:
1512            return _Delay(self, attr)
1513        return getattr(self.soClass.q, attr)
1514
1515
1516class _Delay(SQLExpression):
1517    def __init__(self, proxy, attr):
1518        self.attr = attr
1519        self.proxy = proxy
1520
1521    def __sqlrepr__(self, db):
1522        if self.proxy.soClass is None:
1523            return '_DELAYED_' + self.attr
1524        val = self._resolve()
1525        if isinstance(val, SQLExpression):
1526            val = sqlrepr(val, db)
1527        return val
1528
1529    def tablesUsedImmediate(self):
1530        return getattr(self._resolve(), 'tablesUsedImmediate', lambda: [])()
1531
1532    def components(self):
1533        return getattr(self._resolve(), 'components', lambda: [])()
1534
1535    def _resolve(self):
1536        return getattr(self.proxy, self.attr)
1537
1538    # For AliasTable etc
1539    def fieldName(self):
1540        class _aliasFieldName(SQLExpression):
1541            def __init__(self, proxy):
1542                self.proxy = proxy
1543
1544            def __sqlrepr__(self, db):
1545                return self.proxy._resolve().fieldName
1546        return _aliasFieldName(self)
1547    fieldName = property(fieldName)
1548
1549
1550class _DelayClass(_Delay):
1551    def _resolve(self):
1552        return self.proxy.soClass.sqlmeta.table
1553
1554
1555class _Delay_proxy(object):
1556    def __init__(self, **kw):
1557        self.__dict__.update(kw)
1558
1559######
1560
1561
1562########################################
1563# Global initializations
1564########################################
1565
1566table = TableSpace()
1567const = ConstantSpace()
1568func = const
1569
1570########################################
1571# Testing
1572########################################
1573
1574if __name__ == "__main__":
1575    tests = """
1576>>> AND(table.address.name == "Ian Bicking", table.address.zip > 30000)
1577>>> table.address.name
1578>>> AND(LIKE(table.address.name, "this"), IN(table.address.zip, [100, 200, 300]))
1579>>> Select([table.address.name, table.address.state], where=LIKE(table.address.name, "%ian%"))
1580>>> Select([table.user.name], where=AND(table.user.state == table.states.abbrev))
1581>>> Insert(table.address, [{"name": "BOB", "address": "3049 N. 18th St."}, {"name": "TIM", "address": "409 S. 10th St."}])
1582>>> Insert(table.address, [("BOB", "3049 N. 18th St."), ("TIM", "409 S. 10th St.")], template=('name', 'address'))
1583>>> Delete(table.address, where="BOB"==table.address.name)
1584>>> Update(table.address, {"lastModified": const.NOW()})
1585>>> Replace(table.address, [("BOB", "3049 N. 18th St."), ("TIM", "409 S. 10th St.")], template=('name', 'address'))
1586"""  # noqa: allow long (> 79) lines
1587    for expr in tests.split('\n'):
1588        if not expr.strip():
1589            continue
1590        if expr.startswith('>>> '):
1591            expr = expr[4:]
SQLObject-3.1.0/docs/html/sqlobject/converters.py.html0000644000175000017500000016127312540345350022255 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/converters.py
0001from array import array
0002import datetime
0003from decimal import Decimal
0004import time
0005import sys
0006from .compat import PY2, buffer_type
0007
0008if PY2:
0009    from types import ClassType, InstanceType, NoneType
0010else:
0011    # Use suitable aliases for now
0012    ClassType = type
0013    NoneType = type(None)
0014    # This is may not be what we want in all cases, but will do for now
0015    InstanceType = object
0016
0017
0018try:
0019    from mx.DateTime import DateTimeType, DateTimeDeltaType
0020except ImportError:
0021    try:
0022        from DateTime import DateTimeType, DateTimeDeltaType
0023    except ImportError:
0024        DateTimeType = None
0025        DateTimeDeltaType = None
0026
0027try:
0028    import Sybase
0029    NumericType = Sybase.NumericType
0030except ImportError:
0031    NumericType = None
0032
0033
0034########################################
0035# Quoting
0036########################################
0037
0038sqlStringReplace = [
0039    ("'", "''"),
0040    ('\\', '\\\\'),
0041    ('\000', '\\0'),
0042    ('\b', '\\b'),
0043    ('\n', '\\n'),
0044    ('\r', '\\r'),
0045    ('\t', '\\t'),
0046]
0047
0048
0049class ConverterRegistry:
0050
0051    def __init__(self):
0052        self.basic = {}
0053        self.klass = {}
0054
0055    def registerConverter(self, typ, func):
0056        if type(typ) is ClassType:
0057            self.klass[typ] = func
0058        else:
0059            self.basic[typ] = func
0060
0061    if PY2:
0062        def lookupConverter(self, value, default=None):
0063            if type(value) is InstanceType:
0064                # lookup on klasses dict
0065                return self.klass.get(value.__class__, default)
0066            return self.basic.get(type(value), default)
0067    else:
0068        def lookupConverter(self, value, default=None):
0069            # python 3 doesn't have classic classes, so everything's
0070            # in self.klass due to comparison order in registerConvertor
0071            return self.klass.get(value.__class__, default)
0072
0073converters = ConverterRegistry()
0074registerConverter = converters.registerConverter
0075lookupConverter = converters.lookupConverter
0076
0077
0078def StringLikeConverter(value, db):
0079    if isinstance(value, array):
0080        try:
0081            value = value.tounicode()
0082        except ValueError:
0083            value = value.tostring()
0084    elif isinstance(value, buffer_type):
0085        value = str(value)
0086
0087    if db in ('mysql', 'postgres', 'rdbhost'):
0088        for orig, repl in sqlStringReplace:
0089            value = value.replace(orig, repl)
0090    elif db in ('sqlite', 'firebird', 'sybase', 'maxdb', 'mssql'):
0091        value = value.replace("'", "''")
0092    else:
0093        assert 0, "Database %s unknown" % db
0094    if db in ('postgres', 'rdbhost') and ('\\' in value):
0095        return "E'%s'" % value
0096    return "'%s'" % value
0097
0098registerConverter(str, StringLikeConverter)
0099if PY2:
0100    # noqa for flake8 & python3
0101    registerConverter(unicode, StringLikeConverter)  # noqa
0102registerConverter(array, StringLikeConverter)
0103if PY2:
0104    registerConverter(buffer_type, StringLikeConverter)
0105else:
0106    registerConverter(memoryview, StringLikeConverter)
0107
0108
0109def IntConverter(value, db):
0110    return repr(int(value))
0111
0112registerConverter(int, IntConverter)
0113
0114
0115def LongConverter(value, db):
0116    return str(value)
0117
0118if sys.version_info[0] < 3:
0119    # noqa for flake8 & python3
0120    registerConverter(long, LongConverter)  # noqa
0121
0122if NumericType:
0123    registerConverter(NumericType, IntConverter)
0124
0125
0126def BoolConverter(value, db):
0127    if db in ('postgres', 'rdbhost'):
0128        if value:
0129            return "'t'"
0130        else:
0131            return "'f'"
0132    else:
0133        if value:
0134            return '1'
0135        else:
0136            return '0'
0137
0138registerConverter(bool, BoolConverter)
0139
0140
0141def FloatConverter(value, db):
0142    return repr(value)
0143
0144registerConverter(float, FloatConverter)
0145
0146if DateTimeType:
0147    def mxDateTimeConverter(value, db):
0148        return "'%s'" % value.strftime("%Y-%m-%d %H:%M:%S")
0149
0150    registerConverter(DateTimeType, mxDateTimeConverter)
0151
0152    def mxTimeConverter(value, db):
0153        return "'%s'" % value.strftime("%H:%M:%S")
0154
0155    registerConverter(DateTimeDeltaType, mxTimeConverter)
0156
0157
0158def NoneConverter(value, db):
0159    return "NULL"
0160
0161registerConverter(NoneType, NoneConverter)
0162
0163
0164def SequenceConverter(value, db):
0165    return "(%s)" % ", ".join([sqlrepr(v, db) for v in value])
0166
0167registerConverter(tuple, SequenceConverter)
0168registerConverter(list, SequenceConverter)
0169registerConverter(dict, SequenceConverter)
0170registerConverter(set, SequenceConverter)
0171registerConverter(frozenset, SequenceConverter)
0172
0173if hasattr(time, 'struct_time'):
0174    def StructTimeConverter(value, db):
0175        return time.strftime("'%Y-%m-%d %H:%M:%S'", value)
0176
0177    registerConverter(time.struct_time, StructTimeConverter)
0178
0179
0180def DateTimeConverter(value, db):
0181    return "'%04d-%02d-%02d %02d:%02d:%02d'" % (
0182        value.year, value.month, value.day,
0183        value.hour, value.minute, value.second)
0184
0185
0186def DateTimeConverterMS(value, db):
0187    return "'%04d-%02d-%02d %02d:%02d:%02d.%06d'" % (
0188        value.year, value.month, value.day,
0189        value.hour, value.minute, value.second, value.microsecond)
0190
0191registerConverter(datetime.datetime, DateTimeConverterMS)
0192
0193
0194def DateConverter(value, db):
0195    return "'%04d-%02d-%02d'" % (value.year, value.month, value.day)
0196
0197registerConverter(datetime.date, DateConverter)
0198
0199
0200def TimeConverter(value, db):
0201    return "'%02d:%02d:%02d'" % (value.hour, value.minute, value.second)
0202
0203
0204def TimeConverterMS(value, db):
0205    return "'%02d:%02d:%02d.%06d'" % (value.hour, value.minute,
0206                                      value.second, value.microsecond)
0207
0208registerConverter(datetime.time, TimeConverterMS)
0209
0210
0211def DecimalConverter(value, db):
0212    return value.to_eng_string()
0213
0214registerConverter(Decimal, DecimalConverter)
0215
0216
0217def TimedeltaConverter(value, db):
0218
0219    return """INTERVAL '%d days %d seconds'""" %           (value.days, value.seconds)
0221
0222registerConverter(datetime.timedelta, TimedeltaConverter)
0223
0224
0225def sqlrepr(obj, db=None):
0226    try:
0227        reprFunc = obj.__sqlrepr__
0228    except AttributeError:
0229        converter = lookupConverter(obj)
0230        if converter is None:
0231            raise ValueError("Unknown SQL builtin type: %s for %s" %
0232                             (type(obj), repr(obj)))
0233        return converter(obj, db)
0234    else:
0235        return reprFunc(db)
0236
0237
0238def quote_str(s, db):
0239    if db in ('postgres', 'rdbhost') and ('\\' in s):
0240        return "E'%s'" % s
0241    return "'%s'" % s
0242
0243
0244def unquote_str(s):
0245    if s[:2].upper().startswith("E'") and s.endswith("'"):
0246        return s[2:-1]
0247    elif s.startswith("'") and s.endswith("'"):
0248        return s[1:-1]
0249    else:
0250        return s
SQLObject-3.1.0/docs/html/sqlobject/col.py.html0000644000175000017500000205226312752477506020656 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/col.py
0001"""
0002Col -- SQLObject columns
0003
0004Note that each column object is named BlahBlahCol, and these are used
0005in class definitions.  But there's also a corresponding SOBlahBlahCol
0006object, which is used in SQLObject *classes*.
0007
0008An explanation: when a SQLObject subclass is created, the metaclass
0009looks through your class definition for any subclasses of Col.  It
0010collects them together, and indexes them to do all the database stuff
0011you like, like the magic attributes and whatnot.  It then asks the Col
0012object to create an SOCol object (usually a subclass, actually).  The
0013SOCol object contains all the interesting logic, as well as a record
0014of the attribute name you used and the class it is bound to (set by
0015the metaclass).
0016
0017So, in summary: Col objects are what you define, but SOCol objects
0018are what gets used.
0019"""
0020
0021from array import array
0022from decimal import Decimal
0023from itertools import count
0024import json
0025try:
0026    import cPickle as pickle
0027except ImportError:
0028    import pickle
0029import time
0030from uuid import UUID
0031import weakref
0032
0033from formencode import compound, validators
0034from .classregistry import findClass
0035# Sadly the name "constraints" conflicts with many of the function
0036# arguments in this module, so we rename it:
0037from . import constraints as constrs
0038from . import converters
0039from . import sqlbuilder
0040from .styles import capword
0041from .compat import PY2, string_type, unicode_type, buffer_type
0042
0043import datetime
0044datetime_available = True
0045
0046try:
0047    from mx import DateTime
0048except ImportError:
0049    try:
0050        # old version of mxDateTime,
0051        # or Zope's Version if we're running with Zope
0052        import DateTime
0053    except ImportError:
0054        mxdatetime_available = False
0055    else:
0056        mxdatetime_available = True
0057else:
0058    mxdatetime_available = True
0059
0060DATETIME_IMPLEMENTATION = "datetime"
0061MXDATETIME_IMPLEMENTATION = "mxDateTime"
0062
0063if mxdatetime_available:
0064    if hasattr(DateTime, "Time"):
0065        DateTimeType = type(DateTime.now())
0066        TimeType = type(DateTime.Time())
0067    else:  # Zope
0068        DateTimeType = type(DateTime.DateTime())
0069        TimeType = type(DateTime.DateTime.Time(DateTime.DateTime()))
0070
0071__all__ = ["datetime_available", "mxdatetime_available",
0072           "default_datetime_implementation", "DATETIME_IMPLEMENTATION"]
0073
0074if mxdatetime_available:
0075    __all__.append("MXDATETIME_IMPLEMENTATION")
0076
0077default_datetime_implementation = DATETIME_IMPLEMENTATION
0078
0079if not PY2:
0080    # alias for python 3 compatibility
0081    long = int
0082    # This is to satisfy flake8 under python 3
0083    unicode = str
0084
0085NoDefault = sqlbuilder.NoDefault
0086
0087
0088def use_microseconds(use=True):
0089    if use:
0090        SODateTimeCol.datetimeFormat = '%Y-%m-%d %H:%M:%S.%f'
0091        SOTimeCol.timeFormat = '%H:%M:%S.%f'
0092        dt_types = [(datetime.datetime, converters.DateTimeConverterMS),
0093                    (datetime.time, converters.TimeConverterMS)]
0094    else:
0095        SODateTimeCol.datetimeFormat = '%Y-%m-%d %H:%M:%S'
0096        SOTimeCol.timeFormat = '%H:%M:%S'
0097        dt_types = [(datetime.datetime, converters.DateTimeConverter),
0098                    (datetime.time, converters.TimeConverter)]
0099    for dt_type, converter in dt_types:
0100        converters.registerConverter(dt_type, converter)
0101
0102
0103__all__.append("use_microseconds")
0104
0105
0106creationOrder = count()
0107
0108########################################
0109# Columns
0110########################################
0111
0112# Col is essentially a column definition, it doesn't have much logic to it.
0113
0114
0115class SOCol(object):
0116
0117    def __init__(self,
0118                 name,
0119                 soClass,
0120                 creationOrder,
0121                 dbName=None,
0122                 default=NoDefault,
0123                 defaultSQL=None,
0124                 foreignKey=None,
0125                 alternateID=False,
0126                 alternateMethodName=None,
0127                 constraints=None,
0128                 notNull=NoDefault,
0129                 notNone=NoDefault,
0130                 unique=NoDefault,
0131                 sqlType=None,
0132                 columnDef=None,
0133                 validator=None,
0134                 validator2=None,
0135                 immutable=False,
0136                 cascade=None,
0137                 lazy=False,
0138                 noCache=False,
0139                 forceDBName=False,
0140                 title=None,
0141                 tags=[],
0142                 origName=None,
0143                 dbEncoding=None,
0144                 extra_vars=None):
0145
0146        super(SOCol, self).__init__()
0147
0148        # This isn't strictly true, since we *could* use backquotes or
0149        # " or something (database-specific) around column names, but
0150        # why would anyone *want* to use a name like that?
0151        # @@: I suppose we could actually add backquotes to the
0152        # dbName if we needed to...
0153        if not forceDBName:
0154            assert sqlbuilder.sqlIdentifier(name), (
0155                'Name must be SQL-safe '
0156                '(letters, numbers, underscores): %s (or use forceDBName=True)'
0157                % repr(name))
0158        assert name != 'id', (
0159            'The column name "id" is reserved for SQLObject use '
0160            '(and is implicitly created).')
0161        assert name, "You must provide a name for all columns"
0162
0163        self.columnDef = columnDef
0164        self.creationOrder = creationOrder
0165
0166        self.immutable = immutable
0167
0168        # cascade can be one of:
0169        # None: no constraint is generated
0170        # True: a CASCADE constraint is generated
0171        # False: a RESTRICT constraint is generated
0172        # 'null': a SET NULL trigger is generated
0173        if isinstance(cascade, str):
0174            assert cascade == 'null', (
0175                "The only string value allowed for cascade is 'null' "
0176                "(you gave: %r)" % cascade)
0177        self.cascade = cascade
0178
0179        if not isinstance(constraints, (list, tuple)):
0180            constraints = [constraints]
0181        self.constraints = self.autoConstraints() + constraints
0182
0183        self.notNone = False
0184        if notNull is not NoDefault:
0185            self.notNone = notNull
0186            assert notNone is NoDefault or (not notNone) == (not notNull), (
0187                "The notNull and notNone arguments are aliases, "
0188                "and must not conflict.  "
0189                "You gave notNull=%r, notNone=%r" % (notNull, notNone))
0190        elif notNone is not NoDefault:
0191            self.notNone = notNone
0192        if self.notNone:
0193            self.constraints = [constrs.notNull] + self.constraints
0194
0195        self.name = name
0196        self.soClass = soClass
0197        self._default = default
0198        self.defaultSQL = defaultSQL
0199        self.customSQLType = sqlType
0200
0201        # deal with foreign keys
0202        self.foreignKey = foreignKey
0203        if self.foreignKey:
0204            if origName is not None:
0205                idname = soClass.sqlmeta.style.instanceAttrToIDAttr(origName)
0206            else:
0207                idname = soClass.sqlmeta.style.instanceAttrToIDAttr(name)
0208            if self.name != idname:
0209                self.foreignName = self.name
0210                self.name = idname
0211            else:
0212                self.foreignName = soClass.sqlmeta.style.                      instanceIDAttrToAttr(self.name)
0214        else:
0215            self.foreignName = None
0216
0217        # if they don't give us a specific database name for
0218        # the column, we separate the mixedCase into mixed_case
0219        # and assume that.
0220        if dbName is None:
0221            self.dbName = soClass.sqlmeta.style.pythonAttrToDBColumn(self.name)
0222        else:
0223            self.dbName = dbName
0224
0225        # alternateID means that this is a unique column that
0226        # can be used to identify rows
0227        self.alternateID = alternateID
0228
0229        if unique is NoDefault:
0230            self.unique = alternateID
0231        else:
0232            self.unique = unique
0233        if self.unique and alternateMethodName is None:
0234            self.alternateMethodName = 'by' + capword(self.name)
0235        else:
0236            self.alternateMethodName = alternateMethodName
0237
0238        _validators = self.createValidators()
0239        if validator:
0240            _validators.append(validator)
0241        if validator2:
0242            _validators.insert(0, validator2)
0243        _vlen = len(_validators)
0244        if _vlen:
0245            for _validator in _validators:
0246                _validator.soCol = weakref.proxy(self)
0247        if _vlen == 0:
0248            self.validator = None  # Set sef.{from,to}_python
0249        elif _vlen == 1:
0250            self.validator = _validators[0]
0251        elif _vlen > 1:
0252            self.validator = compound.All.join(
0253                _validators[0], *_validators[1:])
0254        self.noCache = noCache
0255        self.lazy = lazy
0256        # this is in case of ForeignKey, where we rename the column
0257        # and append an ID
0258        self.origName = origName or name
0259        self.title = title
0260        self.tags = tags
0261        self.dbEncoding = dbEncoding
0262
0263        if extra_vars:
0264            for name, value in extra_vars.items():
0265                setattr(self, name, value)
0266
0267    def _set_validator(self, value):
0268        self._validator = value
0269        if self._validator:
0270            self.to_python = self._validator.to_python
0271            self.from_python = self._validator.from_python
0272        else:
0273            self.to_python = None
0274            self.from_python = None
0275
0276    def _get_validator(self):
0277        return self._validator
0278
0279    validator = property(_get_validator, _set_validator)
0280
0281    def createValidators(self):
0282        """Create a list of validators for the column."""
0283        return []
0284
0285    def autoConstraints(self):
0286        return []
0287
0288    def _get_default(self):
0289        # A default can be a callback or a plain value,
0290        # here we resolve the callback
0291        if self._default is NoDefault:
0292            return NoDefault
0293        elif hasattr(self._default, '__sqlrepr__'):
0294            return self._default
0295        elif callable(self._default):
0296            return self._default()
0297        else:
0298            return self._default
0299    default = property(_get_default, None, None)
0300
0301    def _get_joinName(self):
0302        return self.soClass.sqlmeta.style.instanceIDAttrToAttr(self.name)
0303    joinName = property(_get_joinName, None, None)
0304
0305    def __repr__(self):
0306        r = '<%s %s' % (self.__class__.__name__, self.name)
0307        if self.default is not NoDefault:
0308            r += ' default=%s' % repr(self.default)
0309        if self.foreignKey:
0310            r += ' connected to %s' % self.foreignKey
0311        if self.alternateID:
0312            r += ' alternate ID'
0313        if self.notNone:
0314            r += ' not null'
0315        return r + '>'
0316
0317    def createSQL(self):
0318        return ' '.join([self._sqlType()] + self._extraSQL())
0319
0320    def _extraSQL(self):
0321        result = []
0322        if self.notNone or self.alternateID:
0323            result.append('NOT NULL')
0324        if self.unique or self.alternateID:
0325            result.append('UNIQUE')
0326        if self.defaultSQL is not None:
0327            result.append("DEFAULT %s" % self.defaultSQL)
0328        return result
0329
0330    def _sqlType(self):
0331        if self.customSQLType is None:
0332            raise ValueError("Col %s (%s) cannot be used for automatic "
0333                             "schema creation (too abstract)" %
0334                             (self.name, self.__class__))
0335        else:
0336            return self.customSQLType
0337
0338    def _mysqlType(self):
0339        return self._sqlType()
0340
0341    def _postgresType(self):
0342        return self._sqlType()
0343
0344    def _sqliteType(self):
0345        # SQLite is naturally typeless, so as a fallback it uses
0346        # no type.
0347        try:
0348            return self._sqlType()
0349        except ValueError:
0350            return ''
0351
0352    def _sybaseType(self):
0353        return self._sqlType()
0354
0355    def _mssqlType(self):
0356        return self._sqlType()
0357
0358    def _firebirdType(self):
0359        return self._sqlType()
0360
0361    def _maxdbType(self):
0362        return self._sqlType()
0363
0364    def mysqlCreateSQL(self, connection=None):
0365        self.connection = connection
0366        return ' '.join([self.dbName, self._mysqlType()] + self._extraSQL())
0367
0368    def postgresCreateSQL(self):
0369        return ' '.join([self.dbName, self._postgresType()] + self._extraSQL())
0370
0371    def sqliteCreateSQL(self):
0372        return ' '.join([self.dbName, self._sqliteType()] + self._extraSQL())
0373
0374    def sybaseCreateSQL(self):
0375        return ' '.join([self.dbName, self._sybaseType()] + self._extraSQL())
0376
0377    def mssqlCreateSQL(self, connection=None):
0378        self.connection = connection
0379        return ' '.join([self.dbName, self._mssqlType()] + self._extraSQL())
0380
0381    def firebirdCreateSQL(self):
0382        # Ian Sparks pointed out that fb is picky about the order
0383        # of the NOT NULL clause in a create statement.  So, we handle
0384        # them differently for Enum columns.
0385        if not isinstance(self, SOEnumCol):
0386            return ' '.join(
0387                [self.dbName, self._firebirdType()] + self._extraSQL())
0388        else:
0389            return ' '.join(
0390                [self.dbName] + [self._firebirdType()[0]] +
0391                self._extraSQL() + [self._firebirdType()[1]])
0392
0393    def maxdbCreateSQL(self):
0394        return ' '.join([self.dbName, self._maxdbType()] + self._extraSQL())
0395
0396    def __get__(self, obj, type=None):
0397        if obj is None:
0398            # class attribute, return the descriptor itself
0399            return self
0400        if obj.sqlmeta._obsolete:
0401            raise RuntimeError('The object <%s %s> is obsolete' % (
0402                obj.__class__.__name__, obj.id))
0403        if obj.sqlmeta.cacheColumns:
0404            columns = obj.sqlmeta._columnCache
0405            if columns is None:
0406                obj.sqlmeta.loadValues()
0407            try:
0408                return columns[name]  # noqa
0409            except KeyError:
0410                return obj.sqlmeta.loadColumn(self)
0411        else:
0412            return obj.sqlmeta.loadColumn(self)
0413
0414    def __set__(self, obj, value):
0415        if self.immutable:
0416            raise AttributeError("The column %s.%s is immutable" %
0417                                 (obj.__class__.__name__,
0418                                  self.name))
0419        obj.sqlmeta.setColumn(self, value)
0420
0421    def __delete__(self, obj):
0422        raise AttributeError("I can't be deleted from %r" % obj)
0423
0424    def getDbEncoding(self, state, default='utf-8'):
0425        if self.dbEncoding:
0426            return self.dbEncoding
0427        dbEncoding = state.soObject.sqlmeta.dbEncoding
0428        if dbEncoding:
0429            return dbEncoding
0430        try:
0431            connection = state.connection or state.soObject._connection
0432        except AttributeError:
0433            dbEncoding = None
0434        else:
0435            dbEncoding = getattr(connection, "dbEncoding", None)
0436        if not dbEncoding:
0437            dbEncoding = default
0438        return dbEncoding
0439
0440
0441class Col(object):
0442
0443    baseClass = SOCol
0444
0445    def __init__(self, name=None, **kw):
0446        super(Col, self).__init__()
0447        self.__dict__['_name'] = name
0448        self.__dict__['_kw'] = kw
0449        self.__dict__['creationOrder'] = next(creationOrder)
0450        self.__dict__['_extra_vars'] = {}
0451
0452    def _set_name(self, value):
0453        assert self._name is None or self._name == value, (
0454            "You cannot change a name after it has already been set "
0455            "(from %s to %s)" % (self.name, value))
0456        self.__dict__['_name'] = value
0457
0458    def _get_name(self):
0459        return self._name
0460
0461    name = property(_get_name, _set_name)
0462
0463    def withClass(self, soClass):
0464        return self.baseClass(soClass=soClass, name=self._name,
0465                              creationOrder=self.creationOrder,
0466                              columnDef=self,
0467                              extra_vars=self._extra_vars,
0468                              **self._kw)
0469
0470    def __setattr__(self, var, value):
0471        if var == 'name':
0472            super(Col, self).__setattr__(var, value)
0473            return
0474        self._extra_vars[var] = value
0475
0476    def __repr__(self):
0477        return '<%s %s %s>' % (
0478            self.__class__.__name__, hex(abs(id(self)))[2:],
0479            self._name or '(unnamed)')
0480
0481
0482class SOValidator(validators.Validator):
0483    def getDbEncoding(self, state, default='utf-8'):
0484        try:
0485            return self.dbEncoding
0486        except AttributeError:
0487            return self.soCol.getDbEncoding(state, default=default)
0488
0489
0490class SOStringLikeCol(SOCol):
0491    """A common ancestor for SOStringCol and SOUnicodeCol"""
0492    def __init__(self, **kw):
0493        self.length = kw.pop('length', None)
0494        self.varchar = kw.pop('varchar', 'auto')
0495        self.char_binary = kw.pop('char_binary', None)  # A hack for MySQL
0496        if not self.length:
0497            assert self.varchar == 'auto' or not self.varchar,                   "Without a length strings are treated as TEXT, not varchar"
0499            self.varchar = False
0500        elif self.varchar == 'auto':
0501            self.varchar = True
0502
0503        super(SOStringLikeCol, self).__init__(**kw)
0504
0505    def autoConstraints(self):
0506        constraints = [constrs.isString]
0507        if self.length is not None:
0508            constraints += [constrs.MaxLength(self.length)]
0509        return constraints
0510
0511    def _sqlType(self):
0512        if self.customSQLType is not None:
0513            return self.customSQLType
0514        if not self.length:
0515            return 'TEXT'
0516        elif self.varchar:
0517            return 'VARCHAR(%i)' % self.length
0518        else:
0519            return 'CHAR(%i)' % self.length
0520
0521    def _check_case_sensitive(self, db):
0522        if self.char_binary:
0523            raise ValueError("%s does not support "
0524                             "binary character columns" % db)
0525
0526    def _mysqlType(self):
0527        type = self._sqlType()
0528        if self.char_binary:
0529            type += " BINARY"
0530        return type
0531
0532    def _postgresType(self):
0533        self._check_case_sensitive("PostgreSQL")
0534        return super(SOStringLikeCol, self)._postgresType()
0535
0536    def _sqliteType(self):
0537        self._check_case_sensitive("SQLite")
0538        return super(SOStringLikeCol, self)._sqliteType()
0539
0540    def _sybaseType(self):
0541        self._check_case_sensitive("SYBASE")
0542        type = self._sqlType()
0543        if not self.notNone and not self.alternateID:
0544            type += ' NULL'
0545        return type
0546
0547    def _mssqlType(self):
0548        if self.customSQLType is not None:
0549            return self.customSQLType
0550        if not self.length:
0551            if self.connection and self.connection.can_use_max_types():
0552                type = 'VARCHAR(MAX)'
0553            else:
0554                type = 'VARCHAR(4000)'
0555        elif self.varchar:
0556            type = 'VARCHAR(%i)' % self.length
0557        else:
0558            type = 'CHAR(%i)' % self.length
0559        if not self.notNone and not self.alternateID:
0560            type += ' NULL'
0561        return type
0562
0563    def _firebirdType(self):
0564        self._check_case_sensitive("FireBird")
0565        if not self.length:
0566            return 'BLOB SUB_TYPE TEXT'
0567        else:
0568            return self._sqlType()
0569
0570    def _maxdbType(self):
0571        self._check_case_sensitive("SAP DB/MaxDB")
0572        if not self.length:
0573            return 'LONG ASCII'
0574        else:
0575            return self._sqlType()
0576
0577
0578class StringValidator(SOValidator):
0579
0580    def to_python(self, value, state):
0581        if value is None:
0582            return None
0583        try:
0584            connection = state.connection or state.soObject._connection
0585            binaryType = connection._binaryType
0586            dbName = connection.dbName
0587        except AttributeError:
0588            binaryType = type(None)  # Just a simple workaround
0589        dbEncoding = self.getDbEncoding(state, default='ascii')
0590        if isinstance(value, unicode_type):
0591            if PY2:
0592                return value.encode(dbEncoding)
0593            return value
0594        if self.dataType and isinstance(value, self.dataType):
0595            return value
0596        if isinstance(value,
0597                      (str, buffer_type, binaryType,
0598                       sqlbuilder.SQLExpression)):
0599            return value
0600        if hasattr(value, '__unicode__'):
0601            return unicode(value).encode(dbEncoding)
0602        if dbName == 'mysql' and not PY2 and isinstance(value, bytes):
0603            return value.decode('ascii', errors='surrogateescape')
0604        raise validators.Invalid(
0605            "expected a str in the StringCol '%s', got %s %r instead" % (
0606                self.name, type(value), value), value, state)
0607
0608    from_python = to_python
0609
0610
0611class SOStringCol(SOStringLikeCol):
0612
0613    def createValidators(self, dataType=None):
0614        return [StringValidator(name=self.name, dataType=dataType)] +               super(SOStringCol, self).createValidators()
0616
0617
0618class StringCol(Col):
0619    baseClass = SOStringCol
0620
0621
0622class NQuoted(sqlbuilder.SQLExpression):
0623    def __init__(self, value):
0624        assert isinstance(value, unicode_type)
0625        self.value = value
0626
0627    def __hash__(self):
0628        return hash(self.value)
0629
0630    def __sqlrepr__(self, db):
0631        assert db == 'mssql'
0632        return "N" + sqlbuilder.sqlrepr(self.value, db)
0633
0634
0635class UnicodeStringValidator(SOValidator):
0636
0637    def to_python(self, value, state):
0638        if value is None:
0639            return None
0640        if isinstance(value, (unicode_type, sqlbuilder.SQLExpression)):
0641            return value
0642        if isinstance(value, str):
0643            return value.decode(self.getDbEncoding(state))
0644        if isinstance(value, array):  # MySQL
0645            return value.tostring().decode(self.getDbEncoding(state))
0646        if hasattr(value, '__unicode__'):
0647            return unicode(value)
0648        raise validators.Invalid(
0649            "expected a str or a unicode in the UnicodeCol '%s', "
0650            "got %s %r instead" % (
0651                self.name, type(value), value), value, state)
0652
0653    def from_python(self, value, state):
0654        if value is None:
0655            return None
0656        if isinstance(value, (str, sqlbuilder.SQLExpression)):
0657            return value
0658        if isinstance(value, unicode_type):
0659            try:
0660                connection = state.connection or state.soObject._connection
0661            except AttributeError:
0662                pass
0663            else:
0664                if connection.dbName == 'mssql':
0665                    return NQuoted(value)
0666            return value.encode(self.getDbEncoding(state))
0667        if hasattr(value, '__unicode__'):
0668            return unicode(value).encode(self.getDbEncoding(state))
0669        raise validators.Invalid(
0670            "expected a str or a unicode in the UnicodeCol '%s', "
0671            "got %s %r instead" % (
0672                self.name, type(value), value), value, state)
0673
0674
0675class SOUnicodeCol(SOStringLikeCol):
0676    def _mssqlType(self):
0677        if self.customSQLType is not None:
0678            return self.customSQLType
0679        return 'N' + super(SOUnicodeCol, self)._mssqlType()
0680
0681    def createValidators(self):
0682        return [UnicodeStringValidator(name=self.name)] +               super(SOUnicodeCol, self).createValidators()
0684
0685
0686class UnicodeCol(Col):
0687    baseClass = SOUnicodeCol
0688
0689
0690class IntValidator(SOValidator):
0691
0692    def to_python(self, value, state):
0693        if value is None:
0694            return None
0695        if isinstance(value, (int, long, sqlbuilder.SQLExpression)):
0696            return value
0697        for converter, attr_name in (int, '__int__'), (long, '__long__'):
0698            if hasattr(value, attr_name):
0699                try:
0700                    return converter(value)
0701                except:
0702                    break
0703        raise validators.Invalid(
0704            "expected an int in the IntCol '%s', got %s %r instead" % (
0705                self.name, type(value), value), value, state)
0706
0707    from_python = to_python
0708
0709
0710class SOIntCol(SOCol):
0711    # 3-03 @@: support precision, maybe max and min directly
0712    def __init__(self, **kw):
0713        self.length = kw.pop('length', None)
0714        self.unsigned = bool(kw.pop('unsigned', None))
0715        self.zerofill = bool(kw.pop('zerofill', None))
0716        SOCol.__init__(self, **kw)
0717
0718    def autoConstraints(self):
0719        return [constrs.isInt]
0720
0721    def createValidators(self):
0722        return [IntValidator(name=self.name)] +               super(SOIntCol, self).createValidators()
0724
0725    def addSQLAttrs(self, str):
0726        _ret = str
0727        if str is None or len(str) < 1:
0728            return None
0729
0730        if self.length and self.length >= 1:
0731            _ret = "%s(%d)" % (_ret, self.length)
0732        if self.unsigned:
0733            _ret = _ret + " UNSIGNED"
0734        if self.zerofill:
0735            _ret = _ret + " ZEROFILL"
0736        return _ret
0737
0738    def _sqlType(self):
0739        return self.addSQLAttrs("INT")
0740
0741
0742class IntCol(Col):
0743    baseClass = SOIntCol
0744
0745
0746class SOTinyIntCol(SOIntCol):
0747    def _sqlType(self):
0748        return self.addSQLAttrs("TINYINT")
0749
0750
0751class TinyIntCol(Col):
0752    baseClass = SOTinyIntCol
0753
0754
0755class SOSmallIntCol(SOIntCol):
0756    def _sqlType(self):
0757        return self.addSQLAttrs("SMALLINT")
0758
0759
0760class SmallIntCol(Col):
0761    baseClass = SOSmallIntCol
0762
0763
0764class SOMediumIntCol(SOIntCol):
0765    def _sqlType(self):
0766        return self.addSQLAttrs("MEDIUMINT")
0767
0768
0769class MediumIntCol(Col):
0770    baseClass = SOMediumIntCol
0771
0772
0773class SOBigIntCol(SOIntCol):
0774    def _sqlType(self):
0775        return self.addSQLAttrs("BIGINT")
0776
0777
0778class BigIntCol(Col):
0779    baseClass = SOBigIntCol
0780
0781
0782class BoolValidator(SOValidator):
0783
0784    def to_python(self, value, state):
0785        if value is None:
0786            return None
0787        if isinstance(value, (bool, sqlbuilder.SQLExpression)):
0788            return value
0789        if isinstance(value, (int, long)) or hasattr(value, '__nonzero__'):
0790            return bool(value)
0791        raise validators.Invalid(
0792            "expected a bool or an int in the BoolCol '%s', "
0793            "got %s %r instead" % (
0794                self.name, type(value), value), value, state)
0795
0796    from_python = to_python
0797
0798
0799class SOBoolCol(SOCol):
0800    def autoConstraints(self):
0801        return [constrs.isBool]
0802
0803    def createValidators(self):
0804        return [BoolValidator(name=self.name)] +               super(SOBoolCol, self).createValidators()
0806
0807    def _postgresType(self):
0808        return 'BOOL'
0809
0810    def _mysqlType(self):
0811        return "BOOL"
0812
0813    def _sybaseType(self):
0814        return "BIT"
0815
0816    def _mssqlType(self):
0817        return "BIT"
0818
0819    def _firebirdType(self):
0820        return 'INT'
0821
0822    def _maxdbType(self):
0823        return "BOOLEAN"
0824
0825    def _sqliteType(self):
0826        return "BOOLEAN"
0827
0828
0829class BoolCol(Col):
0830    baseClass = SOBoolCol
0831
0832
0833class FloatValidator(SOValidator):
0834
0835    def to_python(self, value, state):
0836        if value is None:
0837            return None
0838        if isinstance(value, (float, int, long, sqlbuilder.SQLExpression)):
0839            return value
0840        for converter, attr_name in (
0841                (float, '__float__'), (int, '__int__'), (long, '__long__')):
0842            if hasattr(value, attr_name):
0843                try:
0844                    return converter(value)
0845                except:
0846                    break
0847        raise validators.Invalid(
0848            "expected a float in the FloatCol '%s', got %s %r instead" % (
0849                self.name, type(value), value), value, state)
0850
0851    from_python = to_python
0852
0853
0854class SOFloatCol(SOCol):
0855    # 3-03 @@: support precision (e.g., DECIMAL)
0856
0857    def autoConstraints(self):
0858        return [constrs.isFloat]
0859
0860    def createValidators(self):
0861        return [FloatValidator(name=self.name)] +               super(SOFloatCol, self).createValidators()
0863
0864    def _sqlType(self):
0865        return 'FLOAT'
0866
0867    def _mysqlType(self):
0868        return "DOUBLE PRECISION"
0869
0870
0871class FloatCol(Col):
0872    baseClass = SOFloatCol
0873
0874
0875class SOKeyCol(SOCol):
0876    key_type = {int: "INT", str: "TEXT"}
0877
0878    # 3-03 @@: this should have a simplified constructor
0879    # Should provide foreign key information for other DBs.
0880
0881    def __init__(self, **kw):
0882        self.refColumn = kw.pop('refColumn', None)
0883        super(SOKeyCol, self).__init__(**kw)
0884
0885    def _idType(self):
0886        return self.soClass.sqlmeta.idType
0887
0888    def _sqlType(self):
0889        return self.key_type[self._idType()]
0890
0891    def _sybaseType(self):
0892        key_type = {int: "NUMERIC(18,0) NULL", str: "TEXT"}
0893        return key_type[self._idType()]
0894
0895    def _mssqlType(self):
0896        key_type = {int: "INT NULL", str: "TEXT"}
0897        return key_type[self._idType()]
0898
0899
0900class KeyCol(Col):
0901
0902    baseClass = SOKeyCol
0903
0904
0905class ForeignKeyValidator(SOValidator):
0906
0907    def __init__(self, *args, **kw):
0908        super(ForeignKeyValidator, self).__init__(*args, **kw)
0909        self.fkIDType = None
0910
0911    def from_python(self, value, state):
0912        if value is None:
0913            return None
0914        # Avoid importing the main module
0915        # to get the SQLObject class for isinstance
0916        if hasattr(value, 'sqlmeta'):
0917            return value
0918        if self.fkIDType is None:
0919            otherTable = findClass(self.soCol.foreignKey,
0920                                   self.soCol.soClass.sqlmeta.registry)
0921            self.fkIDType = otherTable.sqlmeta.idType
0922        try:
0923            value = self.fkIDType(value)
0924            return value
0925        except (ValueError, TypeError):
0926            pass
0927        raise validators.Invalid("expected a %r for the ForeignKey '%s', "
0928                                 "got %s %r instead" %
0929                                 (self.fkIDType, self.name,
0930                                  type(value), value), value, state)
0931
0932
0933class SOForeignKey(SOKeyCol):
0934
0935    def __init__(self, **kw):
0936        foreignKey = kw['foreignKey']
0937        style = kw['soClass'].sqlmeta.style
0938        if kw.get('name'):
0939            kw['origName'] = kw['name']
0940            kw['name'] = style.instanceAttrToIDAttr(kw['name'])
0941        else:
0942            kw['name'] = style.instanceAttrToIDAttr(
0943                style.pythonClassToAttr(foreignKey))
0944        super(SOForeignKey, self).__init__(**kw)
0945
0946    def createValidators(self):
0947        return [ForeignKeyValidator(name=self.name)] +               super(SOForeignKey, self).createValidators()
0949
0950    def _idType(self):
0951        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
0952        return other.sqlmeta.idType
0953
0954    def sqliteCreateSQL(self):
0955        sql = SOKeyCol.sqliteCreateSQL(self)
0956        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
0957        tName = other.sqlmeta.table
0958        idName = self.refColumn or other.sqlmeta.idName
0959        if self.cascade is not None:
0960            if self.cascade == 'null':
0961                action = 'ON DELETE SET NULL'
0962            elif self.cascade:
0963                action = 'ON DELETE CASCADE'
0964            else:
0965                action = 'ON DELETE RESTRICT'
0966        else:
0967            action = ''
0968        constraint = ('CONSTRAINT %(colName)s_exists '
0969                      # 'FOREIGN KEY(%(colName)s) '
0970                      'REFERENCES %(tName)s(%(idName)s) '
0971                      '%(action)s' %
0972                      {'tName': tName,
0973                       'colName': self.dbName,
0974                       'idName': idName,
0975                       'action': action})
0976        sql = ' '.join([sql, constraint])
0977        return sql
0978
0979    def postgresCreateSQL(self):
0980        sql = SOKeyCol.postgresCreateSQL(self)
0981        return sql
0982
0983    def postgresCreateReferenceConstraint(self):
0984        sTName = self.soClass.sqlmeta.table
0985        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
0986        tName = other.sqlmeta.table
0987        idName = self.refColumn or other.sqlmeta.idName
0988        if self.cascade is not None:
0989            if self.cascade == 'null':
0990                action = 'ON DELETE SET NULL'
0991            elif self.cascade:
0992                action = 'ON DELETE CASCADE'
0993            else:
0994                action = 'ON DELETE RESTRICT'
0995        else:
0996            action = ''
0997        constraint = ('ALTER TABLE %(sTName)s '
0998                      'ADD CONSTRAINT %(colName)s_exists '
0999                      'FOREIGN KEY (%(colName)s) '
1000                      'REFERENCES %(tName)s (%(idName)s) '
1001                      '%(action)s' %
1002                      {'tName': tName,
1003                       'colName': self.dbName,
1004                       'idName': idName,
1005                       'action': action,
1006                       'sTName': sTName})
1007        return constraint
1008
1009    def mysqlCreateReferenceConstraint(self):
1010        sTName = self.soClass.sqlmeta.table
1011        sTLocalName = sTName.split('.')[-1]
1012        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
1013        tName = other.sqlmeta.table
1014        idName = self.refColumn or other.sqlmeta.idName
1015        if self.cascade is not None:
1016            if self.cascade == 'null':
1017                action = 'ON DELETE SET NULL'
1018            elif self.cascade:
1019                action = 'ON DELETE CASCADE'
1020            else:
1021                action = 'ON DELETE RESTRICT'
1022        else:
1023            action = ''
1024        constraint = ('ALTER TABLE %(sTName)s '
1025                      'ADD CONSTRAINT %(sTLocalName)s_%(colName)s_exists '
1026                      'FOREIGN KEY (%(colName)s) '
1027                      'REFERENCES %(tName)s (%(idName)s) '
1028                      '%(action)s' %
1029                      {'tName': tName,
1030                       'colName': self.dbName,
1031                       'idName': idName,
1032                       'action': action,
1033                       'sTName': sTName,
1034                       'sTLocalName': sTLocalName})
1035        return constraint
1036
1037    def mysqlCreateSQL(self, connection=None):
1038        return SOKeyCol.mysqlCreateSQL(self, connection)
1039
1040    def sybaseCreateSQL(self):
1041        sql = SOKeyCol.sybaseCreateSQL(self)
1042        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
1043        tName = other.sqlmeta.table
1044        idName = self.refColumn or other.sqlmeta.idName
1045        reference = ('REFERENCES %(tName)s(%(idName)s) ' %
1046                     {'tName': tName,
1047                      'idName': idName})
1048        sql = ' '.join([sql, reference])
1049        return sql
1050
1051    def sybaseCreateReferenceConstraint(self):
1052        # @@: Code from above should be moved here
1053        return None
1054
1055    def mssqlCreateSQL(self, connection=None):
1056        sql = SOKeyCol.mssqlCreateSQL(self, connection)
1057        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
1058        tName = other.sqlmeta.table
1059        idName = self.refColumn or other.sqlmeta.idName
1060        reference = ('REFERENCES %(tName)s(%(idName)s) ' %
1061                     {'tName': tName,
1062                      'idName': idName})
1063        sql = ' '.join([sql, reference])
1064        return sql
1065
1066    def mssqlCreateReferenceConstraint(self):
1067        # @@: Code from above should be moved here
1068        return None
1069
1070    def maxdbCreateSQL(self):
1071        other = findClass(self.foreignKey, self.soClass.sqlmeta.registry)
1072        fidName = self.dbName
1073        # I assume that foreign key name is identical
1074        # to the id of the reference table
1075        sql = ' '.join([fidName, self._maxdbType()])
1076        tName = other.sqlmeta.table
1077        idName = self.refColumn or other.sqlmeta.idName
1078        sql = sql + ',' + '\n'
1079        sql = sql + 'FOREIGN KEY (%s) REFERENCES %s(%s)' % (fidName, tName,
1080                                                            idName)
1081        return sql
1082
1083    def maxdbCreateReferenceConstraint(self):
1084        # @@: Code from above should be moved here
1085        return None
1086
1087
1088class ForeignKey(KeyCol):
1089
1090    baseClass = SOForeignKey
1091
1092    def __init__(self, foreignKey=None, **kw):
1093        super(ForeignKey, self).__init__(foreignKey=foreignKey, **kw)
1094
1095
1096class EnumValidator(SOValidator):
1097
1098    def to_python(self, value, state):
1099        if value in self.enumValues:
1100            # Only encode on python 2 - on python 3, the database driver
1101            # will handle this
1102            if isinstance(value, unicode_type) and PY2:
1103                dbEncoding = self.getDbEncoding(state)
1104                value = value.encode(dbEncoding)
1105            return value
1106        elif not self.notNone and value is None:
1107            return None
1108        raise validators.Invalid(
1109            "expected a member of %r in the EnumCol '%s', got %r instead" % (
1110                self.enumValues, self.name, value), value, state)
1111
1112    from_python = to_python
1113
1114
1115class SOEnumCol(SOCol):
1116
1117    def __init__(self, **kw):
1118        self.enumValues = kw.pop('enumValues', None)
1119        assert self.enumValues is not None,               'You must provide an enumValues keyword argument'
1121        super(SOEnumCol, self).__init__(**kw)
1122
1123    def autoConstraints(self):
1124        return [constrs.isString, constrs.InList(self.enumValues)]
1125
1126    def createValidators(self):
1127        return [EnumValidator(name=self.name, enumValues=self.enumValues,
1128                              notNone=self.notNone)] +               super(SOEnumCol, self).createValidators()
1130
1131    def _mysqlType(self):
1132        # We need to map None in the enum expression to an appropriate
1133        # condition on NULL
1134        if None in self.enumValues:
1135            return "ENUM(%s)" % ', '.join(
1136                [sqlbuilder.sqlrepr(v, 'mysql') for v in self.enumValues
1137                    if v is not None])
1138        else:
1139            return "ENUM(%s) NOT NULL" % ', '.join(
1140                [sqlbuilder.sqlrepr(v, 'mysql') for v in self.enumValues])
1141
1142    def _postgresType(self):
1143        length = max(map(self._getlength, self.enumValues))
1144        enumValues = ', '.join(
1145            [sqlbuilder.sqlrepr(v, 'postgres') for v in self.enumValues])
1146        checkConstraint = "CHECK (%s in (%s))" % (self.dbName, enumValues)
1147        return "VARCHAR(%i) %s" % (length, checkConstraint)
1148
1149    _sqliteType = _postgresType
1150
1151    def _sybaseType(self):
1152        return self._postgresType()
1153
1154    def _mssqlType(self):
1155        return self._postgresType()
1156
1157    def _firebirdType(self):
1158        length = max(map(self._getlength, self.enumValues))
1159        enumValues = ', '.join(
1160            [sqlbuilder.sqlrepr(v, 'firebird') for v in self.enumValues])
1161        checkConstraint = "CHECK (%s in (%s))" % (self.dbName, enumValues)
1162        # NB. Return a tuple, not a string here
1163        return "VARCHAR(%i)" % (length), checkConstraint
1164
1165    def _maxdbType(self):
1166        raise TypeError("Enum type is not supported on MAX DB")
1167
1168    def _getlength(self, obj):
1169        """
1170        None counts as 0; everything else uses len()
1171        """
1172        if obj is None:
1173            return 0
1174        else:
1175            return len(obj)
1176
1177
1178class EnumCol(Col):
1179    baseClass = SOEnumCol
1180
1181
1182class SetValidator(SOValidator):
1183    """
1184    Translates Python tuples into SQL comma-delimited SET strings.
1185    """
1186
1187    def to_python(self, value, state):
1188        if isinstance(value, str):
1189            return tuple(value.split(","))
1190        raise validators.Invalid(
1191            "expected a string in the SetCol '%s', got %s %r instead" % (
1192                self.name, type(value), value), value, state)
1193
1194    def from_python(self, value, state):
1195        if isinstance(value, string_type):
1196            value = (value,)
1197        try:
1198            return ",".join(value)
1199        except:
1200            raise validators.Invalid(
1201                "expected a string or a sequence of strings "
1202                "in the SetCol '%s', got %s %r instead" % (
1203                    self.name, type(value), value), value, state)
1204
1205
1206class SOSetCol(SOCol):
1207    def __init__(self, **kw):
1208        self.setValues = kw.pop('setValues', None)
1209        assert self.setValues is not None,               'You must provide a setValues keyword argument'
1211        super(SOSetCol, self).__init__(**kw)
1212
1213    def autoConstraints(self):
1214        return [constrs.isString, constrs.InList(self.setValues)]
1215
1216    def createValidators(self):
1217        return [SetValidator(name=self.name, setValues=self.setValues)] +               super(SOSetCol, self).createValidators()
1219
1220    def _mysqlType(self):
1221        return "SET(%s)" % ', '.join(
1222            [sqlbuilder.sqlrepr(v, 'mysql') for v in self.setValues])
1223
1224
1225class SetCol(Col):
1226    baseClass = SOSetCol
1227
1228
1229class DateTimeValidator(validators.DateValidator):
1230    def to_python(self, value, state):
1231        if value is None:
1232            return None
1233        if isinstance(value,
1234                      (datetime.datetime, datetime.date,
1235                       datetime.time, sqlbuilder.SQLExpression)):
1236            return value
1237        if mxdatetime_available:
1238            if isinstance(value, DateTimeType):
1239                # convert mxDateTime instance to datetime
1240                if (self.format.find("%H") >= 0) or                      (self.format.find("%T")) >= 0:
1242                    return datetime.datetime(value.year, value.month,
1243                                             value.day,
1244                                             value.hour, value.minute,
1245                                             int(value.second))
1246                else:
1247                    return datetime.date(value.year, value.month, value.day)
1248            elif isinstance(value, TimeType):
1249                # convert mxTime instance to time
1250                if self.format.find("%d") >= 0:
1251                    return datetime.timedelta(seconds=value.seconds)
1252                else:
1253                    return datetime.time(value.hour, value.minute,
1254                                         int(value.second))
1255        try:
1256            if self.format.find(".%f") >= 0:
1257                if '.' in value:
1258                    _value = value.split('.')
1259                    microseconds = _value[-1]
1260                    _l = len(microseconds)
1261                    if _l < 6:
1262                        _value[-1] = microseconds + '0' * (6 - _l)
1263                    elif _l > 6:
1264                        _value[-1] = microseconds[:6]
1265                    if _l != 6:
1266                        value = '.'.join(_value)
1267                else:
1268                    value += '.0'
1269            return datetime.datetime.strptime(value, self.format)
1270        except:
1271            raise validators.Invalid(
1272                "expected a date/time string of the '%s' format "
1273                "in the DateTimeCol '%s', got %s %r instead" % (
1274                    self.format, self.name, type(value), value), value, state)
1275
1276    def from_python(self, value, state):
1277        if value is None:
1278            return None
1279        if isinstance(value,
1280                      (datetime.datetime, datetime.date,
1281                       datetime.time, sqlbuilder.SQLExpression)):
1282            return value
1283        if hasattr(value, "strftime"):
1284            return value.strftime(self.format)
1285        raise validators.Invalid(
1286            "expected a datetime in the DateTimeCol '%s', "
1287            "got %s %r instead" % (
1288                self.name, type(value), value), value, state)
1289
1290if mxdatetime_available:
1291    class MXDateTimeValidator(validators.DateValidator):
1292        def to_python(self, value, state):
1293            if value is None:
1294                return None
1295            if isinstance(value,
1296                          (DateTimeType, TimeType, sqlbuilder.SQLExpression)):
1297                return value
1298            if isinstance(value, datetime.datetime):
1299                return DateTime.DateTime(value.year, value.month, value.day,
1300                                         value.hour, value.minute,
1301                                         value.second)
1302            elif isinstance(value, datetime.date):
1303                return DateTime.Date(value.year, value.month, value.day)
1304            elif isinstance(value, datetime.time):
1305                return DateTime.Time(value.hour, value.minute, value.second)
1306            elif isinstance(value, datetime.timedelta):
1307                if value.days:
1308                    raise validators.Invalid(
1309                        "the value for the TimeCol '%s' must has days=0, "
1310                        "it has days=%d" % (self.name, value.days),
1311                        value, state)
1312                return DateTime.Time(seconds=value.seconds)
1313            try:
1314                if self.format.find(".%f") >= 0:
1315                    if '.' in value:
1316                        _value = value.split('.')
1317                        microseconds = _value[-1]
1318                        _l = len(microseconds)
1319                        if _l < 6:
1320                            _value[-1] = microseconds + '0' * (6 - _l)
1321                        elif _l > 6:
1322                            _value[-1] = microseconds[:6]
1323                        if _l != 6:
1324                            value = '.'.join(_value)
1325                    else:
1326                        value += '.0'
1327                value = datetime.datetime.strptime(value, self.format)
1328                return DateTime.DateTime(value.year, value.month, value.day,
1329                                         value.hour, value.minute,
1330                                         value.second)
1331            except:
1332                raise validators.Invalid(
1333                    "expected a date/time string of the '%s' format "
1334                    "in the DateTimeCol '%s', got %s %r instead" % (
1335                        self.format, self.name, type(value), value),
1336                    value, state)
1337
1338        def from_python(self, value, state):
1339            if value is None:
1340                return None
1341            if isinstance(value,
1342                          (DateTimeType, TimeType, sqlbuilder.SQLExpression)):
1343                return value
1344            if hasattr(value, "strftime"):
1345                return value.strftime(self.format)
1346            raise validators.Invalid(
1347                "expected a mxDateTime in the DateTimeCol '%s', "
1348                "got %s %r instead" % (
1349                    self.name, type(value), value), value, state)
1350
1351
1352class SODateTimeCol(SOCol):
1353    datetimeFormat = '%Y-%m-%d %H:%M:%S.%f'
1354
1355    def __init__(self, **kw):
1356        datetimeFormat = kw.pop('datetimeFormat', None)
1357        if datetimeFormat:
1358            self.datetimeFormat = datetimeFormat
1359        super(SODateTimeCol, self).__init__(**kw)
1360
1361    def createValidators(self):
1362        _validators = super(SODateTimeCol, self).createValidators()
1363        if default_datetime_implementation == DATETIME_IMPLEMENTATION:
1364            validatorClass = DateTimeValidator
1365        elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
1366            validatorClass = MXDateTimeValidator
1367        if default_datetime_implementation:
1368            _validators.insert(0, validatorClass(name=self.name,
1369                                                 format=self.datetimeFormat))
1370        return _validators
1371
1372    def _mysqlType(self):
1373        if self.connection and self.connection.can_use_microseconds():
1374            return 'DATETIME(6)'
1375        else:
1376            return 'DATETIME'
1377
1378    def _postgresType(self):
1379        return 'TIMESTAMP'
1380
1381    def _sybaseType(self):
1382        return 'DATETIME'
1383
1384    def _mssqlType(self):
1385        if self.connection and self.connection.can_use_microseconds():
1386            return 'DATETIME2(6)'
1387        else:
1388            return 'DATETIME'
1389
1390    def _sqliteType(self):
1391        return 'TIMESTAMP'
1392
1393    def _firebirdType(self):
1394        return 'TIMESTAMP'
1395
1396    def _maxdbType(self):
1397        return 'TIMESTAMP'
1398
1399
1400class DateTimeCol(Col):
1401    baseClass = SODateTimeCol
1402
1403    @staticmethod
1404    def now():
1405        if default_datetime_implementation == DATETIME_IMPLEMENTATION:
1406            return datetime.datetime.now()
1407        elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
1408            return DateTime.now()
1409        else:
1410            assert 0, ("No datetime implementation available "
1411                       "(DATETIME_IMPLEMENTATION=%r)"
1412                       % DATETIME_IMPLEMENTATION)
1413
1414
1415class DateValidator(DateTimeValidator):
1416    def to_python(self, value, state):
1417        if isinstance(value, datetime.datetime):
1418            value = value.date()
1419        if isinstance(value, (datetime.date, sqlbuilder.SQLExpression)):
1420            return value
1421        value = super(DateValidator, self).to_python(value, state)
1422        if isinstance(value, datetime.datetime):
1423            value = value.date()
1424        return value
1425
1426    from_python = to_python
1427
1428
1429class SODateCol(SOCol):
1430    dateFormat = '%Y-%m-%d'
1431
1432    def __init__(self, **kw):
1433        dateFormat = kw.pop('dateFormat', None)
1434        if dateFormat:
1435            self.dateFormat = dateFormat
1436        super(SODateCol, self).__init__(**kw)
1437
1438    def createValidators(self):
1439        """Create a validator for the column.
1440
1441        Can be overriden in descendants.
1442
1443        """
1444        _validators = super(SODateCol, self).createValidators()
1445        if default_datetime_implementation == DATETIME_IMPLEMENTATION:
1446            validatorClass = DateValidator
1447        elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
1448            validatorClass = MXDateTimeValidator
1449        if default_datetime_implementation:
1450            _validators.insert(0, validatorClass(name=self.name,
1451                                                 format=self.dateFormat))
1452        return _validators
1453
1454    def _mysqlType(self):
1455        return 'DATE'
1456
1457    def _postgresType(self):
1458        return 'DATE'
1459
1460    def _sybaseType(self):
1461        return self._postgresType()
1462
1463    def _mssqlType(self):
1464        """
1465        SQL Server doesn't have  a DATE data type, to emulate we use a vc(10)
1466        """
1467        return 'VARCHAR(10)'
1468
1469    def _firebirdType(self):
1470        return 'DATE'
1471
1472    def _maxdbType(self):
1473        return 'DATE'
1474
1475    def _sqliteType(self):
1476        return 'DATE'
1477
1478
1479class DateCol(Col):
1480    baseClass = SODateCol
1481
1482
1483class TimeValidator(DateTimeValidator):
1484    def to_python(self, value, state):
1485        if isinstance(value, (datetime.time, sqlbuilder.SQLExpression)):
1486            return value
1487        if isinstance(value, datetime.timedelta):
1488            if value.days:
1489                raise validators.Invalid(
1490                    "the value for the TimeCol '%s' must has days=0, "
1491                    "it has days=%d" % (self.name, value.days), value, state)
1492            return datetime.time(*time.gmtime(value.seconds)[3:6])
1493        value = super(TimeValidator, self).to_python(value, state)
1494        if isinstance(value, datetime.datetime):
1495            value = value.time()
1496        return value
1497
1498    from_python = to_python
1499
1500
1501class SOTimeCol(SOCol):
1502    timeFormat = '%H:%M:%S.%f'
1503
1504    def __init__(self, **kw):
1505        timeFormat = kw.pop('timeFormat', None)
1506        if timeFormat:
1507            self.timeFormat = timeFormat
1508        super(SOTimeCol, self).__init__(**kw)
1509
1510    def createValidators(self):
1511        _validators = super(SOTimeCol, self).createValidators()
1512        if default_datetime_implementation == DATETIME_IMPLEMENTATION:
1513            validatorClass = TimeValidator
1514        elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
1515            validatorClass = MXDateTimeValidator
1516        if default_datetime_implementation:
1517            _validators.insert(0, validatorClass(name=self.name,
1518                                                 format=self.timeFormat))
1519        return _validators
1520
1521    def _mysqlType(self):
1522        if self.connection and self.connection.can_use_microseconds():
1523            return 'TIME(6)'
1524        else:
1525            return 'TIME'
1526
1527    def _postgresType(self):
1528        return 'TIME'
1529
1530    def _sybaseType(self):
1531        return 'TIME'
1532
1533    def _mssqlType(self):
1534        if self.connection and self.connection.can_use_microseconds():
1535            return 'TIME(6)'
1536        else:
1537            return 'TIME'
1538
1539    def _sqliteType(self):
1540        return 'TIME'
1541
1542    def _firebirdType(self):
1543        return 'TIME'
1544
1545    def _maxdbType(self):
1546        return 'TIME'
1547
1548
1549class TimeCol(Col):
1550    baseClass = SOTimeCol
1551
1552
1553class SOTimestampCol(SODateTimeCol):
1554    """
1555    Necessary to support MySQL's use of TIMESTAMP versus DATETIME types
1556    """
1557
1558    def __init__(self, **kw):
1559        if 'default' not in kw:
1560            kw['default'] = None
1561        SOCol.__init__(self, **kw)
1562
1563    def _mysqlType(self):
1564        if self.connection and self.connection.can_use_microseconds():
1565            return 'TIMESTAMP(6)'
1566        else:
1567            return 'TIMESTAMP'
1568
1569
1570class TimestampCol(Col):
1571    baseClass = SOTimestampCol
1572
1573
1574class TimedeltaValidator(SOValidator):
1575    def to_python(self, value, state):
1576        return value
1577
1578    from_python = to_python
1579
1580
1581class SOTimedeltaCol(SOCol):
1582    def _postgresType(self):
1583        return 'INTERVAL'
1584
1585    def createValidators(self):
1586        return [TimedeltaValidator(name=self.name)] +               super(SOTimedeltaCol, self).createValidators()
1588
1589
1590class TimedeltaCol(Col):
1591    baseClass = SOTimedeltaCol
1592
1593
1594class DecimalValidator(SOValidator):
1595    def to_python(self, value, state):
1596        if value is None:
1597            return None
1598        if isinstance(value, (int, long, Decimal, sqlbuilder.SQLExpression)):
1599            return value
1600        if isinstance(value, float):
1601            value = str(value)
1602        try:
1603            connection = state.connection or state.soObject._connection
1604        except AttributeError:
1605            pass
1606        else:
1607            if hasattr(connection, "decimalSeparator"):
1608                value = value.replace(connection.decimalSeparator, ".")
1609        try:
1610            return Decimal(value)
1611        except:
1612            raise validators.Invalid(
1613                "expected a Decimal in the DecimalCol '%s', "
1614                "got %s %r instead" % (
1615                    self.name, type(value), value), value, state)
1616
1617    def from_python(self, value, state):
1618        if value is None:
1619            return None
1620        if isinstance(value, float):
1621            value = str(value)
1622        if isinstance(value, string_type):
1623            try:
1624                connection = state.connection or state.soObject._connection
1625            except AttributeError:
1626                pass
1627            else:
1628                if hasattr(connection, "decimalSeparator"):
1629                    value = value.replace(connection.decimalSeparator, ".")
1630            try:
1631                return Decimal(value)
1632            except:
1633                raise validators.Invalid(
1634                    "can not parse Decimal value '%s' "
1635                    "in the DecimalCol from '%s'" % (
1636                        value, getattr(state, 'soObject', '(unknown)')),
1637                    value, state)
1638        if isinstance(value, (int, long, Decimal, sqlbuilder.SQLExpression)):
1639            return value
1640        raise validators.Invalid(
1641            "expected a Decimal in the DecimalCol '%s', got %s %r instead" % (
1642                self.name, type(value), value), value, state)
1643
1644
1645class SODecimalCol(SOCol):
1646
1647    def __init__(self, **kw):
1648        self.size = kw.pop('size', NoDefault)
1649        assert self.size is not NoDefault,               "You must give a size argument"
1651        self.precision = kw.pop('precision', NoDefault)
1652        assert self.precision is not NoDefault,               "You must give a precision argument"
1654        super(SODecimalCol, self).__init__(**kw)
1655
1656    def _sqlType(self):
1657        return 'DECIMAL(%i, %i)' % (self.size, self.precision)
1658
1659    def createValidators(self):
1660        return [DecimalValidator(name=self.name)] +               super(SODecimalCol, self).createValidators()
1662
1663
1664class DecimalCol(Col):
1665    baseClass = SODecimalCol
1666
1667
1668class SOCurrencyCol(SODecimalCol):
1669
1670    def __init__(self, **kw):
1671        pushKey(kw, 'size', 10)
1672        pushKey(kw, 'precision', 2)
1673        super(SOCurrencyCol, self).__init__(**kw)
1674
1675
1676class CurrencyCol(DecimalCol):
1677    baseClass = SOCurrencyCol
1678
1679
1680class DecimalStringValidator(DecimalValidator):
1681    def to_python(self, value, state):
1682        value = super(DecimalStringValidator, self).to_python(value, state)
1683        if self.precision and isinstance(value, Decimal):
1684            assert value < self.max,                   "Value must be less than %s" % int(self.max)
1686            value = value.quantize(self.precision)
1687        return value
1688
1689    def from_python(self, value, state):
1690        value = super(DecimalStringValidator, self).from_python(value, state)
1691        if isinstance(value, Decimal):
1692            if self.precision:
1693                assert value < self.max,                       "Value must be less than %s" % int(self.max)
1695                value = value.quantize(self.precision)
1696            value = value.to_eng_string()
1697        elif isinstance(value, (int, long)):
1698            value = str(value)
1699        return value
1700
1701
1702class SODecimalStringCol(SOStringCol):
1703    def __init__(self, **kw):
1704        self.size = kw.pop('size', NoDefault)
1705        assert (self.size is not NoDefault) and (self.size >= 0),               "You must give a size argument as a positive integer"
1707        self.precision = kw.pop('precision', NoDefault)
1708        assert (self.precision is not NoDefault) and (self.precision >= 0),               "You must give a precision argument as a positive integer"
1710        kw['length'] = int(self.size) + int(self.precision)
1711        self.quantize = kw.pop('quantize', False)
1712        assert isinstance(self.quantize, bool),               "quantize argument must be Boolean True/False"
1714        super(SODecimalStringCol, self).__init__(**kw)
1715
1716    def createValidators(self):
1717        if self.quantize:
1718            v = DecimalStringValidator(
1719                name=self.name,
1720                precision=Decimal(10) ** (-1 * int(self.precision)),
1721                max=Decimal(10) ** (int(self.size) - int(self.precision)))
1722        else:
1723            v = DecimalStringValidator(name=self.name, precision=0)
1724        return [v] +               super(SODecimalStringCol, self).createValidators(dataType=Decimal)
1726
1727
1728class DecimalStringCol(StringCol):
1729    baseClass = SODecimalStringCol
1730
1731
1732class BinaryValidator(SOValidator):
1733    """
1734    Validator for binary types.
1735
1736    We're assuming that the per-database modules provide some form
1737    of wrapper type for binary conversion.
1738    """
1739
1740    _cachedValue = None
1741
1742    def to_python(self, value, state):
1743        if value is None:
1744            return None
1745        try:
1746            connection = state.connection or state.soObject._connection
1747        except AttributeError:
1748            dbName = None
1749            binaryType = type(None)  # Just a simple workaround
1750        else:
1751            dbName = connection.dbName
1752            binaryType = connection._binaryType
1753        if isinstance(value, str):
1754            if dbName == "sqlite":
1755                if not PY2:
1756                    value = bytes(value, 'ascii')
1757                value = connection.module.decode(value)
1758            if dbName == "mysql" and not PY2:
1759                value = value.encode('ascii', errors='surrogateescape')
1760            return value
1761        if isinstance(value, (buffer_type, binaryType)):
1762            cachedValue = self._cachedValue
1763            if cachedValue and cachedValue[1] == value:
1764                return cachedValue[0]
1765            if isinstance(value, array):  # MySQL
1766                return value.tostring()
1767            if not PY2 and isinstance(value, memoryview):
1768                return value.tobytes()
1769            return str(value)  # buffer => string
1770        raise validators.Invalid(
1771            "expected a string in the BLOBCol '%s', got %s %r instead" % (
1772                self.name, type(value), value), value, state)
1773
1774    def from_python(self, value, state):
1775        if value is None:
1776            return None
1777        connection = state.connection or state.soObject._connection
1778        binary = connection.createBinary(value)
1779        if not PY2 and isinstance(binary, memoryview):
1780            binary = str(binary.tobytes(), 'ascii')
1781        self._cachedValue = (value, binary)
1782        return binary
1783
1784
1785class SOBLOBCol(SOStringCol):
1786    def __init__(self, **kw):
1787        # Change the default from 'auto' to False -
1788        # this is a (mostly) binary column
1789        if 'varchar' not in kw:
1790            kw['varchar'] = False
1791        super(SOBLOBCol, self).__init__(**kw)
1792
1793    def createValidators(self):
1794        return [BinaryValidator(name=self.name)] +               super(SOBLOBCol, self).createValidators()
1796
1797    def _mysqlType(self):
1798        length = self.length
1799        varchar = self.varchar
1800        if length:
1801            if length >= 2 ** 24:
1802                return varchar and "LONGTEXT" or "LONGBLOB"
1803            if length >= 2 ** 16:
1804                return varchar and "MEDIUMTEXT" or "MEDIUMBLOB"
1805            if length >= 2 ** 8:
1806                return varchar and "TEXT" or "BLOB"
1807        return varchar and "TINYTEXT" or "TINYBLOB"
1808
1809    def _postgresType(self):
1810        return 'BYTEA'
1811
1812    def _mssqlType(self):
1813        if self.connection and self.connection.can_use_max_types():
1814            return 'VARBINARY(MAX)'
1815        else:
1816            return "IMAGE"
1817
1818
1819class BLOBCol(StringCol):
1820    baseClass = SOBLOBCol
1821
1822
1823class PickleValidator(BinaryValidator):
1824    """
1825    Validator for pickle types.  A pickle type is simply a binary type
1826    with hidden pickling, so that we can simply store any kind of
1827    stuff in a particular column.
1828
1829    The support for this relies directly on the support for binary for
1830    your database.
1831    """
1832
1833    def to_python(self, value, state):
1834        if value is None:
1835            return None
1836        if isinstance(value, unicode_type):
1837            dbEncoding = self.getDbEncoding(state, default='ascii')
1838            value = value.encode(dbEncoding)
1839        if isinstance(value, bytes):
1840            return pickle.loads(value)
1841        raise validators.Invalid(
1842            "expected a pickle string in the PickleCol '%s', "
1843            "got %s %r instead" % (
1844                self.name, type(value), value), value, state)
1845
1846    def from_python(self, value, state):
1847        if value is None:
1848            return None
1849        return pickle.dumps(value, self.pickleProtocol)
1850
1851
1852class SOPickleCol(SOBLOBCol):
1853
1854    def __init__(self, **kw):
1855        self.pickleProtocol = kw.pop('pickleProtocol', pickle.HIGHEST_PROTOCOL)
1856        super(SOPickleCol, self).__init__(**kw)
1857
1858    def createValidators(self):
1859        return [PickleValidator(name=self.name,
1860                pickleProtocol=self.pickleProtocol)] +               super(SOPickleCol, self).createValidators()
1862
1863    def _mysqlType(self):
1864        length = self.length
1865        if length:
1866            if length >= 2 ** 24:
1867                return "LONGBLOB"
1868            if length >= 2 ** 16:
1869                return "MEDIUMBLOB"
1870        return "BLOB"
1871
1872
1873class PickleCol(BLOBCol):
1874    baseClass = SOPickleCol
1875
1876
1877class UuidValidator(SOValidator):
1878
1879    def to_python(self, value, state):
1880        if value is None:
1881            return None
1882        if isinstance(value, str):
1883            return UUID(value)
1884        raise validators.Invalid(
1885            "expected string in the UuidCol '%s', "
1886            "got %s %r instead" % (
1887                self.name, type(value), value), value, state)
1888
1889    def from_python(self, value, state):
1890        if value is None:
1891            return None
1892        if isinstance(value, UUID):
1893            return str(value)
1894        raise validators.Invalid(
1895            "expected uuid in the UuidCol '%s', "
1896            "got %s %r instead" % (
1897                self.name, type(value), value), value, state)
1898
1899
1900class SOUuidCol(SOCol):
1901    def createValidators(self):
1902        return [UuidValidator(name=self.name)] +               super(SOUuidCol, self).createValidators()
1904
1905    def _sqlType(self):
1906        return 'VARCHAR(36)'
1907
1908    def _postgresType(self):
1909        return 'UUID'
1910
1911
1912class UuidCol(Col):
1913    baseClass = SOUuidCol
1914
1915
1916class JsonbValidator(SOValidator):
1917
1918    def to_python(self, value, state):
1919        return value
1920
1921    def from_python(self, value, state):
1922        if value is None:
1923            return json.dumps(None)
1924        if isinstance(value, (dict, list, unicode, int, long, float, bool)):
1925            return json.dumps(value)
1926        raise validators.Invalid(
1927            "expect one of the following types "
1928            "(dict, list, unicode, int, long, float, bool) for '%s', "
1929            "got %s %r instead" % (
1930                self.name, type(value), value), value, state)
1931
1932
1933class SOJsonbCol(SOCol):
1934    def createValidators(self):
1935        return [JsonbValidator(name=self.name)] +               super(SOJsonbCol, self).createValidators()
1937
1938    def _postgresType(self):
1939        return 'JSONB'
1940
1941
1942class JsonbCol(Col):
1943    baseClass = SOJsonbCol
1944
1945
1946class JSONValidator(StringValidator):
1947
1948    def to_python(self, value, state):
1949        if value is None:
1950            return None
1951        if isinstance(value, string_type):
1952            return json.loads(value)
1953        raise validators.Invalid(
1954            "expected a JSON str in the JSONCol '%s', "
1955            "got %s %r instead" % (
1956                self.name, type(value), value), value, state)
1957
1958    def from_python(self, value, state):
1959        if value is None:
1960            return None
1961        if isinstance(value,
1962                      (bool, int, float, long, dict, list, string_type)):
1963            return json.dumps(value)
1964        raise validators.Invalid(
1965            "expected an object suitable for JSON in the JSONCol '%s', "
1966            "got %s %r instead" % (
1967                self.name, type(value), value), value, state)
1968
1969
1970class SOJSONCol(SOStringCol):
1971
1972    def createValidators(self):
1973        return [JSONValidator(name=self.name)] +               super(SOJSONCol, self).createValidators()
1975
1976
1977class JSONCol(StringCol):
1978    baseClass = SOJSONCol
1979
1980
1981def pushKey(kw, name, value):
1982    if name not in kw:
1983        kw[name] = value
1984
1985all = []
1986# Use copy() to avoid 'dictionary changed' issues on python 3
1987for key, value in globals().copy().items():
1988    if isinstance(value, type) and (issubclass(value, (Col, SOCol))):
1989        all.append(key)
1990__all__.extend(all)
1991del all
SQLObject-3.1.0/docs/html/sqlobject/compat.py.html0000644000175000017500000002122612735240476021350 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/compat.py
0001import sys
0002import types
0003
0004# Credit to six authors: https://pypi.python.org/pypi/six
0005# License: MIT
0006
0007
0008def with_metaclass(meta, *bases):
0009    """Create a base class with a metaclass."""
0010    # This requires a bit of explanation: the basic idea is to make a dummy
0011    # metaclass for one level of class instantiation that replaces itself with
0012    # the actual metaclass.
0013
0014    class metaclass(meta):
0015        def __new__(cls, name, this_bases, d):
0016            return meta(name, bases, d)
0017    return type.__new__(metaclass, 'temporary_class', (), {})
0018
0019# Compatability definitions (inspired by six)
0020PY2 = sys.version_info[0] < 3
0021if PY2:
0022    # disable flake8 checks on python 3
0023    string_type = basestring  # noqa
0024    unicode_type = unicode  # noqa
0025    class_types = (type, types.ClassType)
0026    buffer_type = buffer  # noqa
0027else:
0028    string_type = str
0029    unicode_type = str
0030    class_types = (type,)
0031    buffer_type = memoryview
SQLObject-3.1.0/docs/html/sqlobject/mssql/0000755000175000017500000000000012754657361017712 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/mssql/__init__.py.html0000644000175000017500000000725312464733165022770 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/mssql/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import mssqlconnection
0006    return mssqlconnection.MSSQLConnection
0007
0008registerConnection(['mssql'], builder)
SQLObject-3.1.0/docs/html/sqlobject/constraints.py.html0000644000175000017500000005115612503207731022427 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/constraints.py
0001"""
0002Constraints
0003"""
0004
0005from sqlobject.compat import PY2
0006
0007if not PY2:
0008    # alias for python 3 compatability
0009    long = int
0010
0011
0012class BadValue(ValueError):
0013
0014    def __init__(self, desc, obj, col, value, *args):
0015        self.desc = desc
0016        self.col = col
0017
0018        # I want these objects to be garbage-collectable, so
0019        # I just keep their repr:
0020        self.obj = repr(obj)
0021        self.value = repr(value)
0022        fullDesc = "%s.%s %s (you gave: %s)"                      % (obj, col.name, desc, value)
0024        ValueError.__init__(self, fullDesc, *args)
0025
0026
0027def isString(obj, col, value):
0028    if not isinstance(value, str):
0029        raise BadValue("only allows strings", obj, col, value)
0030
0031
0032def notNull(obj, col, value):
0033    if value is None:
0034        raise BadValue("is defined NOT NULL", obj, col, value)
0035
0036
0037def isInt(obj, col, value):
0038    if not isinstance(value, (int, long)):
0039        raise BadValue("only allows integers", obj, col, value)
0040
0041
0042def isFloat(obj, col, value):
0043    if not isinstance(value, (int, long, float)):
0044        raise BadValue("only allows floating point numbers", obj, col, value)
0045
0046
0047def isBool(obj, col, value):
0048    if not isinstance(value, bool):
0049        raise BadValue("only allows booleans", obj, col, value)
0050
0051
0052class InList:
0053
0054    def __init__(self, l):
0055        self.list = l
0056
0057    def __call__(self, obj, col, value):
0058        if value not in self.list:
0059            raise BadValue("accepts only values in %s" % repr(self.list),
0060                           obj, col, value)
0061
0062
0063class MaxLength:
0064
0065    def __init__(self, length):
0066        self.length = length
0067
0068    def __call__(self, obj, col, value):
0069        try:
0070            length = len(value)
0071        except TypeError:
0072            raise BadValue("object does not have a length",
0073                           obj, col, value)
0074        if length > self.length:
0075            raise BadValue("must be shorter in length than %s"
0076                           % self.length,
0077                           obj, col, value)
SQLObject-3.1.0/docs/html/sqlobject/rdbhost/0000755000175000017500000000000012754657361020220 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/rdbhost/__init__.py.html0000644000175000017500000000726512464733165023301 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/rdbhost/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import rdbhostconnection
0006    return rdbhostconnection.RdbhostConnection
0007
0008registerConnection(['rdbhost'], builder)
SQLObject-3.1.0/docs/html/sqlobject/versioning/0000755000175000017500000000000012754657361020736 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/versioning/__init__.py.html0000644000175000017500000011151212470177652024006 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/versioning/__init__.py
0001from datetime import datetime
0002from sqlobject import col, events, SQLObject, AND
0003
0004
0005class Version(SQLObject):
0006    def restore(self):
0007        values = self.sqlmeta.asDict()
0008        del values['id']
0009        del values['masterID']
0010        del values['dateArchived']
0011        for _col in self.extraCols:
0012            del values[_col]
0013        self.masterClass.get(self.masterID).set(**values)
0014
0015    def nextVersion(self):
0016        version = self.select(
0017            AND(self.q.masterID == self.masterID, self.q.id > self.id),
0018            orderBy=self.q.id)
0019        if version.count():
0020            return version[0]
0021        else:
0022            return self.master
0023
0024    def getChangedFields(self):
0025        next = self.nextVersion()
0026        columns = self.masterClass.sqlmeta.columns
0027        fields = []
0028        for column in columns:
0029            if column not in ["dateArchived", "id", "masterID"]:
0030                if getattr(self, column) != getattr(next, column):
0031                    fields.append(column.title())
0032
0033        return fields
0034
0035    @classmethod
0036    def select(cls, clause=None, *args, **kw):
0037        if not getattr(cls, '_connection', None):
0038            cls._connection = cls.masterClass._connection
0039        return super(Version, cls).select(clause, *args, **kw)
0040
0041    def __getattr__(self, attr):
0042        if attr in self.__dict__:
0043            return self.__dict__[attr]
0044        else:
0045            return getattr(self.master, attr)
0046
0047
0048def getColumns(columns, cls):
0049    for column, defi in cls.sqlmeta.columnDefinitions.items():
0050        if column.endswith("ID") and isinstance(defi, col.ForeignKey):
0051            column = column[:-2]
0052
0053        # remove incompatible constraints
0054        kwds = dict(defi._kw)
0055        for kw in ["alternateID", "unique"]:
0056            if kw in kwds:
0057                del kwds[kw]
0058        columns[column] = defi.__class__(**kwds)
0059
0060    # ascend heirarchy
0061    if cls.sqlmeta.parentClass:
0062        getColumns(columns, cls.sqlmeta.parentClass)
0063
0064
0065class Versioning(object):
0066    def __init__(self, extraCols=None):
0067        if extraCols:
0068            self.extraCols = extraCols
0069        else:
0070            self.extraCols = {}
0071        pass
0072
0073    def __addtoclass__(self, soClass, name):
0074        self.name = name
0075        self.soClass = soClass
0076
0077        attrs = {'dateArchived': col.DateTimeCol(default=datetime.now),
0078                 'master': col.ForeignKey(self.soClass.__name__),
0079                 'masterClass': self.soClass,
0080                 'extraCols': self.extraCols
0081                 }
0082
0083        getColumns(attrs, self.soClass)
0084
0085        attrs.update(self.extraCols)
0086
0087        self.versionClass = type(self.soClass.__name__ + 'Versions',
0088                                 (Version,),
0089                                 attrs)
0090
0091        if '_connection' in self.soClass.__dict__:
0092            self.versionClass._connection =                   self.soClass.__dict__['_connection']
0094
0095        events.listen(self.createTable,
0096                      soClass, events.CreateTableSignal)
0097        events.listen(self.rowUpdate, soClass,
0098                      events.RowUpdateSignal)
0099
0100    def createVersionTable(self, cls, conn):
0101        self.versionClass.createTable(ifNotExists=True, connection=conn)
0102
0103    def createTable(self, soClass, connection, extra_sql, post_funcs):
0104        assert soClass is self.soClass
0105        post_funcs.append(self.createVersionTable)
0106
0107    def rowUpdate(self, instance, kwargs):
0108        if instance.childName and instance.childName != self.soClass.__name__:
0109            return  # if you want your child class versioned, version it
0110
0111        values = instance.sqlmeta.asDict()
0112        del values['id']
0113        values['masterID'] = instance.id
0114        self.versionClass(connection=instance._connection, **values)
0115
0116    def __get__(self, obj, type=None):
0117        if obj is None:
0118            return self
0119        return self.versionClass.select(
0120            self.versionClass.q.masterID == obj.id, connection=obj._connection)
SQLObject-3.1.0/docs/html/sqlobject/util/0000755000175000017500000000000012754657361017530 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/util/__init__.py.html0000644000175000017500000000470610223346763022601 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/util/__init__.py
0001#
0002
SQLObject-3.1.0/docs/html/sqlobject/classregistry.py.html0000644000175000017500000010555512470415717022771 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/classregistry.py
0001"""
0002classresolver.py
0003  2 February 2004, Ian Bicking <ianb@colorstudy.com>
0004
0005Resolves strings to classes, and runs callbacks when referenced
0006classes are created.
0007
0008Classes are referred to only by name, not by module.  So that
0009identically-named classes can coexist, classes are put into individual
0010registries, which are keyed on strings (names).  These registries are
0011created on demand.
0012
0013Use like::
0014
0015    >>> import classregistry
0016    >>> registry = classregistry.registry('MyModules')
0017    >>> def afterMyClassExists(cls):
0018    ...    print('Class finally exists: %s' % cls)
0019    >>> registry.addClassCallback('MyClass', afterMyClassExists)
0020    >>> class MyClass:
0021    ...    pass
0022    >>> registry.addClass(MyClass)
0023    Class finally exists: MyClass
0024
0025"""
0026
0027
0028class ClassRegistry(object):
0029    """
0030    We'll be dealing with classes that reference each other, so
0031    class C1 may reference C2 (in a join), while C2 references
0032    C1 right back.  Since classes are created in an order, there
0033    will be a point when C1 exists but C2 doesn't.  So we deal
0034    with classes by name, and after each class is created we
0035    try to fix up any references by replacing the names with
0036    actual classes.
0037
0038    Here we keep a dictionaries of class names to classes -- note
0039    that the classes might be spread among different modules, so
0040    since we pile them together names need to be globally unique,
0041    to just module unique.
0042    Like needSet below, the container dictionary is keyed by the
0043    class registry.
0044    """
0045
0046    def __init__(self, name):
0047        self.name = name
0048        self.classes = {}
0049        self.callbacks = {}
0050        self.genericCallbacks = []
0051
0052    def addClassCallback(self, className, callback, *args, **kw):
0053        """
0054        Whenever a name is substituted for the class, you can register
0055        a callback that will be called when the needed class is
0056        created.  If it's already been created, the callback will be
0057        called immediately.
0058        """
0059        if className in self.classes:
0060            callback(self.classes[className], *args, **kw)
0061        else:
0062            self.callbacks.setdefault(className, []).append(
0063                (callback, args, kw))
0064
0065    def addCallback(self, callback, *args, **kw):
0066        """
0067        This callback is called for all classes, not just specific
0068        ones (like addClassCallback).
0069        """
0070        self.genericCallbacks.append((callback, args, kw))
0071        for cls in self.classes.values():
0072            callback(cls, *args, **kw)
0073
0074    def addClass(self, cls):
0075        """
0076        Everytime a class is created, we add it to the registry, so
0077        that other classes can find it by name.  We also call any
0078        callbacks that are waiting for the class.
0079        """
0080        if cls.__name__ in self.classes:
0081            import sys
0082            other = self.classes[cls.__name__]
0083            raise ValueError(
0084                "class %s is already in the registry (other class is "
0085                "%r, from the module %s in %s; attempted new class is "
0086                "%r, from the module %s in %s)"
0087                % (cls.__name__,
0088                   other, other.__module__,
0089                   getattr(sys.modules.get(other.__module__),
0090                           '__file__', '(unknown)'),
0091                   cls, cls.__module__,
0092                   getattr(sys.modules.get(cls.__module__),
0093                           '__file__', '(unknown)')))
0094        self.classes[cls.__name__] = cls
0095        if cls.__name__ in self.callbacks:
0096            for callback, args, kw in self.callbacks[cls.__name__]:
0097                callback(cls, *args, **kw)
0098            del self.callbacks[cls.__name__]
0099        for callback, args, kw in self.genericCallbacks:
0100            callback(cls, *args, **kw)
0101
0102    def getClass(self, className):
0103        try:
0104            return self.classes[className]
0105        except KeyError:
0106            all = sorted(self.classes.keys())
0107            raise KeyError(
0108                "No class %s found in the registry %s (these classes "
0109                "exist: %s)"
0110                % (className, self.name or '[default]', ', '.join(all)))
0111
0112    def allClasses(self):
0113        return self.classes.values()
0114
0115
0116class _MasterRegistry(object):
0117    """
0118    This singleton holds all the class registries.  There can be
0119    multiple registries to hold different unrelated sets of classes
0120    that reside in the same process.  These registries are named with
0121    strings, and are created on demand.  The MasterRegistry module
0122    global holds the singleton.
0123    """
0124
0125    def __init__(self):
0126        self.registries = {}
0127
0128    def registry(self, item):
0129        if item not in self.registries:
0130            self.registries[item] = ClassRegistry(item)
0131        return self.registries[item]
0132
0133MasterRegistry = _MasterRegistry()
0134registry = MasterRegistry.registry
0135
0136
0137def findClass(name, class_registry=None):
0138    return registry(class_registry).getClass(name)
SQLObject-3.1.0/docs/html/sqlobject/joins.py.html0000644000175000017500000047142512473144200021204 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/joins.py
0001from itertools import count
0002from . import boundattributes
0003from . import classregistry
0004from . import events
0005from . import styles
0006from . import sqlbuilder
0007from .styles import capword
0008
0009__all__ = ['MultipleJoin', 'SQLMultipleJoin', 'RelatedJoin', 'SQLRelatedJoin',
0010           'SingleJoin', 'ManyToMany', 'OneToMany']
0011
0012creationOrder = count()
0013NoDefault = sqlbuilder.NoDefault
0014
0015
0016def getID(obj):
0017    try:
0018        return obj.id
0019    except AttributeError:
0020        return int(obj)
0021
0022
0023class Join(object):
0024
0025    def __init__(self, otherClass=None, **kw):
0026        kw['otherClass'] = otherClass
0027        self.kw = kw
0028        self._joinMethodName = self.kw.pop('joinMethodName', None)
0029        self.creationOrder = next(creationOrder)
0030
0031    def _set_joinMethodName(self, value):
0032        assert self._joinMethodName == value or self._joinMethodName is None,               "You have already given an explicit joinMethodName (%s), "               "and you are now setting it to %s" % (self._joinMethodName, value)
0035        self._joinMethodName = value
0036
0037    def _get_joinMethodName(self):
0038        return self._joinMethodName
0039
0040    joinMethodName = property(_get_joinMethodName, _set_joinMethodName)
0041    name = joinMethodName
0042
0043    def withClass(self, soClass):
0044        if 'joinMethodName' in self.kw:
0045            self._joinMethodName = self.kw['joinMethodName']
0046            del self.kw['joinMethodName']
0047        return self.baseClass(creationOrder=self.creationOrder,
0048                              soClass=soClass,
0049                              joinDef=self,
0050                              joinMethodName=self._joinMethodName,
0051                              **self.kw)
0052
0053
0054# A join is separate from a foreign key, i.e., it is
0055# many-to-many, or one-to-many where the *other* class
0056# has the foreign key.
0057
0058
0059class SOJoin(object):
0060
0061    def __init__(self,
0062                 creationOrder,
0063                 soClass=None,
0064                 otherClass=None,
0065                 joinColumn=None,
0066                 joinMethodName=None,
0067                 orderBy=NoDefault,
0068                 joinDef=None):
0069        self.creationOrder = creationOrder
0070        self.soClass = soClass
0071        self.joinDef = joinDef
0072        self.otherClassName = otherClass
0073        classregistry.registry(soClass.sqlmeta.registry).addClassCallback(
0074            otherClass, self._setOtherClass)
0075        self.joinColumn = joinColumn
0076        self.joinMethodName = joinMethodName
0077        self._orderBy = orderBy
0078        if not self.joinColumn:
0079            # Here we set up the basic join, which is
0080            # one-to-many, where the other class points to
0081            # us.
0082            self.joinColumn = styles.getStyle(
0083                self.soClass).tableReference(self.soClass.sqlmeta.table)
0084
0085    def orderBy(self):
0086        if self._orderBy is NoDefault:
0087            self._orderBy = self.otherClass.sqlmeta.defaultOrder
0088        return self._orderBy
0089    orderBy = property(orderBy)
0090
0091    def _setOtherClass(self, cls):
0092        self.otherClass = cls
0093
0094    def hasIntermediateTable(self):
0095        return False
0096
0097    def _applyOrderBy(self, results, defaultSortClass):
0098        if self.orderBy is not None:
0099            doSort(results, self.orderBy)
0100        return results
0101
0102
0103class MinType(object):
0104    """Sort less than everything, for handling None's in the results"""
0105    # functools.total_ordering would simplify this, but isn't available
0106    # for python 2.6
0107
0108    def __lt__(self, other):
0109        if self is other:
0110            return False
0111        return True
0112
0113    def __eq__(self, other):
0114        return self is other
0115
0116    def __gt__(self, other):
0117        return False
0118
0119    def __le__(self, other):
0120        return True
0121
0122    def __ge__(self, other):
0123        if self is other:
0124            return True
0125        return False
0126
0127
0128Min = MinType()
0129
0130
0131def doSort(results, orderBy):
0132    if isinstance(orderBy, (tuple, list)):
0133        if len(orderBy) == 1:
0134            orderBy = orderBy[0]
0135        else:
0136            # Rely on stable sort results, since this is simpler
0137            # than trying to munge everything into a single sort key
0138            doSort(results, orderBy[0])
0139            doSort(results, orderBy[1:])
0140            return
0141    if isinstance(orderBy, sqlbuilder.DESC)          and isinstance(orderBy.expr, sqlbuilder.SQLObjectField):
0143        orderBy = '-' + orderBy.expr.original
0144    elif isinstance(orderBy, sqlbuilder.SQLObjectField):
0145        orderBy = orderBy.original
0146    # @@: but we don't handle more complex expressions for orderings
0147    if orderBy.startswith('-'):
0148        orderBy = orderBy[1:]
0149        reverse = True
0150    else:
0151        reverse = False
0152
0153    def sortkey(x, attr=orderBy):
0154        a = getattr(x, attr)
0155        if a is None:
0156            return Min
0157        return a
0158    results.sort(key=sortkey, reverse=reverse)
0159
0160
0161# This is a one-to-many
0162
0163
0164class SOMultipleJoin(SOJoin):
0165
0166    def __init__(self, addRemoveName=None, **kw):
0167        # addRemovePrefix is something like @@
0168        SOJoin.__init__(self, **kw)
0169
0170        # Here we generate the method names
0171        if not self.joinMethodName:
0172            name = self.otherClassName[0].lower() + self.otherClassName[1:]
0173            if name.endswith('s'):
0174                name = name + "es"
0175            else:
0176                name = name + "s"
0177            self.joinMethodName = name
0178        if addRemoveName:
0179            self.addRemoveName = addRemoveName
0180        else:
0181            self.addRemoveName = capword(self.otherClassName)
0182
0183    def performJoin(self, inst):
0184        ids = inst._connection._SO_selectJoin(
0185            self.otherClass,
0186            self.joinColumn,
0187            inst.id)
0188        if inst.sqlmeta._perConnection:
0189            conn = inst._connection
0190        else:
0191            conn = None
0192        return self._applyOrderBy(
0193            [self.otherClass.get(id, conn) for (id,) in ids if id is not None],
0194            self.otherClass)
0195
0196    def _dbNameToPythonName(self):
0197        for column in self.otherClass.sqlmeta.columns.values():
0198            if column.dbName == self.joinColumn:
0199                return column.name
0200        return self.soClass.sqlmeta.style.dbColumnToPythonAttr(self.joinColumn)
0201
0202
0203class MultipleJoin(Join):
0204    baseClass = SOMultipleJoin
0205
0206
0207class SOSQLMultipleJoin(SOMultipleJoin):
0208
0209    def performJoin(self, inst):
0210        if inst.sqlmeta._perConnection:
0211            conn = inst._connection
0212        else:
0213            conn = None
0214        pythonColumn = self._dbNameToPythonName()
0215        results = self.otherClass.select(
0216            getattr(self.otherClass.q, pythonColumn) == inst.id,
0217            connection=conn)
0218        return results.orderBy(self.orderBy)
0219
0220
0221class SQLMultipleJoin(Join):
0222    baseClass = SOSQLMultipleJoin
0223
0224
0225# This is a many-to-many join, with an intermediary table
0226
0227
0228class SORelatedJoin(SOMultipleJoin):
0229
0230    def __init__(self,
0231                 otherColumn=None,
0232                 intermediateTable=None,
0233                 createRelatedTable=True,
0234                 **kw):
0235        self.intermediateTable = intermediateTable
0236        self.otherColumn = otherColumn
0237        self.createRelatedTable = createRelatedTable
0238        SOMultipleJoin.__init__(self, **kw)
0239        classregistry.registry(
0240            self.soClass.sqlmeta.registry).addClassCallback(
0241            self.otherClassName, self._setOtherRelatedClass)
0242
0243    def _setOtherRelatedClass(self, otherClass):
0244        if not self.intermediateTable:
0245            names = [self.soClass.sqlmeta.table,
0246                     otherClass.sqlmeta.table]
0247            names.sort()
0248            self.intermediateTable = '%s_%s' % (names[0], names[1])
0249        if not self.otherColumn:
0250            self.otherColumn = self.soClass.sqlmeta.style.tableReference(
0251                otherClass.sqlmeta.table)
0252
0253    def hasIntermediateTable(self):
0254        return True
0255
0256    def performJoin(self, inst):
0257        ids = inst._connection._SO_intermediateJoin(
0258            self.intermediateTable,
0259            self.otherColumn,
0260            self.joinColumn,
0261            inst.id)
0262        if inst.sqlmeta._perConnection:
0263            conn = inst._connection
0264        else:
0265            conn = None
0266        return self._applyOrderBy(
0267            [self.otherClass.get(id, conn) for (id,) in ids if id is not None],
0268            self.otherClass)
0269
0270    def remove(self, inst, other):
0271        inst._connection._SO_intermediateDelete(
0272            self.intermediateTable,
0273            self.joinColumn,
0274            getID(inst),
0275            self.otherColumn,
0276            getID(other))
0277
0278    def add(self, inst, other):
0279        inst._connection._SO_intermediateInsert(
0280            self.intermediateTable,
0281            self.joinColumn,
0282            getID(inst),
0283            self.otherColumn,
0284            getID(other))
0285
0286
0287class RelatedJoin(MultipleJoin):
0288    baseClass = SORelatedJoin
0289
0290
0291# helper classes to SQLRelatedJoin
0292
0293
0294class OtherTableToJoin(sqlbuilder.SQLExpression):
0295    def __init__(self, otherTable, otherIdName, interTable, joinColumn):
0296        self.otherTable = otherTable
0297        self.otherIdName = otherIdName
0298        self.interTable = interTable
0299        self.joinColumn = joinColumn
0300
0301    def tablesUsedImmediate(self):
0302        return [self.otherTable, self.interTable]
0303
0304    def __sqlrepr__(self, db):
0305        return '%s.%s = %s.%s' % (self.otherTable, self.otherIdName,
0306                                  self.interTable, self.joinColumn)
0307
0308
0309class JoinToTable(sqlbuilder.SQLExpression):
0310    def __init__(self, table, idName, interTable, joinColumn):
0311        self.table = table
0312        self.idName = idName
0313        self.interTable = interTable
0314        self.joinColumn = joinColumn
0315
0316    def tablesUsedImmediate(self):
0317        return [self.table, self.interTable]
0318
0319    def __sqlrepr__(self, db):
0320        return '%s.%s = %s.%s' % (self.interTable, self.joinColumn, self.table,
0321                                  self.idName)
0322
0323
0324class TableToId(sqlbuilder.SQLExpression):
0325    def __init__(self, table, idName, idValue):
0326        self.table = table
0327        self.idName = idName
0328        self.idValue = idValue
0329
0330    def tablesUsedImmediate(self):
0331        return [self.table]
0332
0333    def __sqlrepr__(self, db):
0334        return '%s.%s = %s' % (self.table, self.idName, self.idValue)
0335
0336
0337class SOSQLRelatedJoin(SORelatedJoin):
0338    def performJoin(self, inst):
0339        if inst.sqlmeta._perConnection:
0340            conn = inst._connection
0341        else:
0342            conn = None
0343        results = self.otherClass.select(sqlbuilder.AND(
0344            OtherTableToJoin(
0345                self.otherClass.sqlmeta.table, self.otherClass.sqlmeta.idName,
0346                self.intermediateTable, self.otherColumn
0347            ),
0348            JoinToTable(
0349                self.soClass.sqlmeta.table, self.soClass.sqlmeta.idName,
0350                self.intermediateTable, self.joinColumn
0351            ),
0352            TableToId(self.soClass.sqlmeta.table, self.soClass.sqlmeta.idName,
0353                      inst.id),
0354        ), clauseTables=(self.soClass.sqlmeta.table,
0355                         self.otherClass.sqlmeta.table,
0356                         self.intermediateTable),
0357            connection=conn)
0358        return results.orderBy(self.orderBy)
0359
0360
0361class SQLRelatedJoin(RelatedJoin):
0362    baseClass = SOSQLRelatedJoin
0363
0364
0365class SOSingleJoin(SOMultipleJoin):
0366
0367    def __init__(self, **kw):
0368        self.makeDefault = kw.pop('makeDefault', False)
0369        SOMultipleJoin.__init__(self, **kw)
0370
0371    def performJoin(self, inst):
0372        if inst.sqlmeta._perConnection:
0373            conn = inst._connection
0374        else:
0375            conn = None
0376        pythonColumn = self._dbNameToPythonName()
0377        results = self.otherClass.select(
0378            getattr(self.otherClass.q, pythonColumn) == inst.id,
0379            connection=conn
0380        )
0381        if results.count() == 0:
0382            if not self.makeDefault:
0383                return None
0384            else:
0385                kw = {self.soClass.sqlmeta.style.
0386                      instanceIDAttrToAttr(pythonColumn): inst}
0387                # instanciating the otherClass with all
0388                return self.otherClass(**kw)
0389        else:
0390            return results[0]
0391
0392
0393class SingleJoin(Join):
0394    baseClass = SOSingleJoin
0395
0396
0397class SOManyToMany(object):
0398
0399    def __init__(self, soClass, name, join,
0400                 intermediateTable, joinColumn, otherColumn,
0401                 createJoinTable, **attrs):
0402        self.name = name
0403        self.intermediateTable = intermediateTable
0404        self.joinColumn = joinColumn
0405        self.otherColumn = otherColumn
0406        self.createJoinTable = createJoinTable
0407        self.soClass = self.otherClass = None
0408        for name, value in attrs.items():
0409            setattr(self, name, value)
0410        classregistry.registry(
0411            soClass.sqlmeta.registry).addClassCallback(
0412            join, self._setOtherClass)
0413        classregistry.registry(
0414            soClass.sqlmeta.registry).addClassCallback(
0415            soClass.__name__, self._setThisClass)
0416
0417    def _setThisClass(self, soClass):
0418        self.soClass = soClass
0419        if self.soClass and self.otherClass:
0420            self._finishSet()
0421
0422    def _setOtherClass(self, otherClass):
0423        self.otherClass = otherClass
0424        if self.soClass and self.otherClass:
0425            self._finishSet()
0426
0427    def _finishSet(self):
0428        if self.intermediateTable is None:
0429            names = [self.soClass.sqlmeta.table,
0430                     self.otherClass.sqlmeta.table]
0431            names.sort()
0432            self.intermediateTable = '%s_%s' % (names[0], names[1])
0433        if not self.otherColumn:
0434            self.otherColumn = self.soClass.sqlmeta.style.tableReference(
0435                self.otherClass.sqlmeta.table)
0436        if not self.joinColumn:
0437            self.joinColumn = styles.getStyle(
0438                self.soClass).tableReference(self.soClass.sqlmeta.table)
0439        events.listen(self.event_CreateTableSignal,
0440                      self.soClass, events.CreateTableSignal)
0441        events.listen(self.event_CreateTableSignal,
0442                      self.otherClass, events.CreateTableSignal)
0443        self.clause = (
0444            (self.otherClass.q.id ==
0445             sqlbuilder.Field(self.intermediateTable, self.otherColumn)) &
0446            (sqlbuilder.Field(self.intermediateTable, self.joinColumn) ==
0447             self.soClass.q.id))
0448
0449    def __get__(self, obj, type):
0450        if obj is None:
0451            return self
0452        query = (
0453            (self.otherClass.q.id ==
0454             sqlbuilder.Field(self.intermediateTable, self.otherColumn)) &
0455            (sqlbuilder.Field(self.intermediateTable, self.joinColumn) ==
0456             obj.id))
0457        select = self.otherClass.select(query)
0458        return _ManyToManySelectWrapper(obj, self, select)
0459
0460    def event_CreateTableSignal(self, soClass, connection, extra_sql,
0461                                post_funcs):
0462        if self.createJoinTable:
0463            post_funcs.append(self.event_CreateTableSignalPost)
0464
0465    def event_CreateTableSignalPost(self, soClass, connection):
0466        if connection.tableExists(self.intermediateTable):
0467            return
0468        connection._SO_createJoinTable(self)
0469
0470
0471class ManyToMany(boundattributes.BoundFactory):
0472    factory_class = SOManyToMany
0473    __restrict_attributes__ = (
0474        'join', 'intermediateTable',
0475        'joinColumn', 'otherColumn', 'createJoinTable')
0476    __unpackargs__ = ('join',)
0477
0478    # Default values:
0479    intermediateTable = None
0480    joinColumn = None
0481    otherColumn = None
0482    createJoinTable = True
0483
0484
0485class _ManyToManySelectWrapper(object):
0486
0487    def __init__(self, forObject, join, select):
0488        self.forObject = forObject
0489        self.join = join
0490        self.select = select
0491
0492    def __getattr__(self, attr):
0493        # @@: This passes through private variable access too... should it?
0494        # Also magic methods, like __str__
0495        return getattr(self.select, attr)
0496
0497    def __repr__(self):
0498        return '<%s for: %s>' % (self.__class__.__name__, repr(self.select))
0499
0500    def __str__(self):
0501        return str(self.select)
0502
0503    def __iter__(self):
0504        return iter(self.select)
0505
0506    def __getitem__(self, key):
0507        return self.select[key]
0508
0509    def add(self, obj):
0510        obj._connection._SO_intermediateInsert(
0511            self.join.intermediateTable,
0512            self.join.joinColumn,
0513            getID(self.forObject),
0514            self.join.otherColumn,
0515            getID(obj))
0516
0517    def remove(self, obj):
0518        obj._connection._SO_intermediateDelete(
0519            self.join.intermediateTable,
0520            self.join.joinColumn,
0521            getID(self.forObject),
0522            self.join.otherColumn,
0523            getID(obj))
0524
0525    def create(self, **kw):
0526        obj = self.join.otherClass(**kw)
0527        self.add(obj)
0528        return obj
0529
0530
0531class SOOneToMany(object):
0532
0533    def __init__(self, soClass, name, join, joinColumn, **attrs):
0534        self.soClass = soClass
0535        self.name = name
0536        self.joinColumn = joinColumn
0537        for name, value in attrs.items():
0538            setattr(self, name, value)
0539        classregistry.registry(
0540            soClass.sqlmeta.registry).addClassCallback(
0541            join, self._setOtherClass)
0542
0543    def _setOtherClass(self, otherClass):
0544        self.otherClass = otherClass
0545        if not self.joinColumn:
0546            self.joinColumn = styles.getStyle(
0547                self.soClass).tableReference(self.soClass.sqlmeta.table)
0548        self.clause = (
0549            sqlbuilder.Field(self.otherClass.sqlmeta.table, self.joinColumn) ==
0550            self.soClass.q.id)
0551
0552    def __get__(self, obj, type):
0553        if obj is None:
0554            return self
0555        query = (
0556            sqlbuilder.Field(self.otherClass.sqlmeta.table, self.joinColumn) ==
0557            obj.id)
0558        select = self.otherClass.select(query)
0559        return _OneToManySelectWrapper(obj, self, select)
0560
0561
0562class OneToMany(boundattributes.BoundFactory):
0563    factory_class = SOOneToMany
0564    __restrict_attributes__ = (
0565        'join', 'joinColumn')
0566    __unpackargs__ = ('join',)
0567
0568    # Default values:
0569    joinColumn = None
0570
0571
0572class _OneToManySelectWrapper(object):
0573
0574    def __init__(self, forObject, join, select):
0575        self.forObject = forObject
0576        self.join = join
0577        self.select = select
0578
0579    def __getattr__(self, attr):
0580        # @@: This passes through private variable access too... should it?
0581        # Also magic methods, like __str__
0582        return getattr(self.select, attr)
0583
0584    def __repr__(self):
0585        return '<%s for: %s>' % (self.__class__.__name__, repr(self.select))
0586
0587    def __str__(self):
0588        return str(self.select)
0589
0590    def __iter__(self):
0591        return iter(self.select)
0592
0593    def __getitem__(self, key):
0594        return self.select[key]
0595
0596    def create(self, **kw):
0597        kw[self.join.joinColumn] = self.forObject.id
0598        return self.join.otherClass(**kw)
SQLObject-3.1.0/docs/html/sqlobject/maxdb/0000755000175000017500000000000012754657361017646 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/maxdb/__init__.py.html0000644000175000017500000000735612464733165022730 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/maxdb/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import maxdbconnection
0006    return maxdbconnection.MaxdbConnection
0007
0008registerConnection(['maxdb', 'sapdb'], builder)
SQLObject-3.1.0/docs/html/sqlobject/views.py.html0000644000175000017500000014235412747416060021225 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/views.py
0001from .main import SQLObject
0002from .sqlbuilder import AND, Alias, ColumnAS, LEFTJOINOn,       NoDefault, SQLCall, SQLConstant, SQLObjectField, SQLObjectTable, SQLOp,       Select, sqlrepr
0005
0006
0007class ViewSQLObjectField(SQLObjectField):
0008    def __init__(self, alias, *arg):
0009        SQLObjectField.__init__(self, *arg)
0010        self.alias = alias
0011
0012    def __sqlrepr__(self, db):
0013        return self.alias + "." + self.fieldName
0014
0015    def tablesUsedImmediate(self):
0016        return [self.tableName]
0017
0018
0019class ViewSQLObjectTable(SQLObjectTable):
0020    FieldClass = ViewSQLObjectField
0021
0022    def __getattr__(self, attr):
0023        if attr == 'sqlmeta':
0024            raise AttributeError
0025        return SQLObjectTable.__getattr__(self, attr)
0026
0027    def _getattrFromID(self, attr):
0028        return self.FieldClass(self.soClass.sqlmeta.alias, self.tableName,
0029                               'id', attr, self.soClass, None)
0030
0031    def _getattrFromColumn(self, column, attr):
0032        return self.FieldClass(self.soClass.sqlmeta.alias, self.tableName,
0033                               column.name, attr, self.soClass, column)
0034
0035
0036class ViewSQLObject(SQLObject):
0037    """
0038    A SQLObject class that derives all it's values from other SQLObject
0039    classes. Columns on subclasses should use SQLBuilder constructs for dbName,
0040    and sqlmeta should specify:
0041
0042    * idName as a SQLBuilder construction
0043    * clause as SQLBuilder clause for specifying join conditions
0044      or other restrictions
0045    * table as an optional alternate name for the class alias
0046
0047    See test_views.py for simple examples.
0048    """
0049
0050    def __classinit__(cls, new_attrs):
0051        SQLObject.__classinit__(cls, new_attrs)
0052        # like is_base
0053        if cls.__name__ != 'ViewSQLObject':
0054            dbName = hasattr(cls, '_connection') and                   (cls._connection and cls._connection.dbName) or None
0056
0057            if getattr(cls.sqlmeta, 'table', None):
0058                cls.sqlmeta.alias = cls.sqlmeta.table
0059            else:
0060                cls.sqlmeta.alias =                       cls.sqlmeta.style.pythonClassToDBTable(cls.__name__)
0062            alias = cls.sqlmeta.alias
0063            columns = [ColumnAS(cls.sqlmeta.idName, 'id')]
0064            # {sqlrepr-key: [restriction, *aggregate-column]}
0065            aggregates = {'': [None]}
0066            inverseColumns = dict(
0067                [(y, x) for x, y in cls.sqlmeta.columns.items()])
0068            for col in cls.sqlmeta.columnList:
0069                n = inverseColumns[col]
0070                ascol = ColumnAS(col.dbName, n)
0071                if isAggregate(col.dbName):
0072                    restriction = getattr(col, 'aggregateClause', None)
0073                    if restriction:
0074                        restrictkey = sqlrepr(restriction, dbName)
0075                        aggregates[restrictkey] =                               aggregates.get(restrictkey, [restriction]) +                               [ascol]
0078                    else:
0079                        aggregates[''].append(ascol)
0080                else:
0081                    columns.append(ascol)
0082
0083            metajoin = getattr(cls.sqlmeta, 'join', NoDefault)
0084            clause = getattr(cls.sqlmeta, 'clause', NoDefault)
0085            select = Select(columns,
0086                            distinct=True,
0087                            # @@ LDO check if this really mattered
0088                            # for performance
0089                            # @@ Postgres (and MySQL?) extension!
0090                            # distinctOn=cls.sqlmeta.idName,
0091                            join=metajoin,
0092                            clause=clause)
0093
0094            aggregates = aggregates.values()
0095
0096            if aggregates != [[None]]:
0097                join = []
0098                last_alias = "%s_base" % alias
0099                last_id = "id"
0100                last = Alias(select, last_alias)
0101                columns = [
0102                    ColumnAS(SQLConstant("%s.%s" % (last_alias, x.expr2)),
0103                             x.expr2) for x in columns]
0104
0105                for i, agg in enumerate(aggregates):
0106                    restriction = agg[0]
0107                    if restriction is None:
0108                        restriction = clause
0109                    else:
0110                        restriction = AND(clause, restriction)
0111                    agg = agg[1:]
0112                    agg_alias = "%s_%s" % (alias, i)
0113                    agg_id = '%s_id' % agg_alias
0114                    if not last.q.alias.endswith('base'):
0115                        last = None
0116                    new_alias = Alias(Select(
0117                        [ColumnAS(cls.sqlmeta.idName, agg_id)] + agg,
0118                        groupBy=cls.sqlmeta.idName,
0119                        join=metajoin,
0120                        clause=restriction),
0121                        agg_alias)
0122                    agg_join = LEFTJOINOn(last, new_alias,
0123                                          "%s.%s = %s.%s" % (
0124                                              last_alias, last_id,
0125                                              agg_alias, agg_id))
0126
0127                    join.append(agg_join)
0128                    for col in agg:
0129                        columns.append(
0130                            ColumnAS(SQLConstant(
0131                                "%s.%s" % (agg_alias, col.expr2)),
0132                                col.expr2))
0133
0134                    last = new_alias
0135                    last_alias = agg_alias
0136                    last_id = agg_id
0137                select = Select(columns,
0138                                join=join)
0139
0140            cls.sqlmeta.table = Alias(select, alias)
0141            cls.q = ViewSQLObjectTable(cls)
0142            for n, col in cls.sqlmeta.columns.items():
0143                col.dbName = n
0144
0145
0146def isAggregate(expr):
0147    if isinstance(expr, SQLCall):
0148        return True
0149    if isinstance(expr, SQLOp):
0150        return isAggregate(expr.expr1) or isAggregate(expr.expr2)
0151    return False
SQLObject-3.1.0/docs/html/sqlobject/__version__.py.html0000644000175000017500000000725412754656553022363 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/__version__.py
0001version = '3.1.0'
0002major = 3
0003minor = 1
0004micro = 0
0005release_level = 'final'
0006serial = 0
0007version_info = (major, minor, micro, release_level, serial)
SQLObject-3.1.0/docs/html/sqlobject/sresults.py.html0000644000175000017500000036656112472652005021760 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/sresults.py
0001from . import dbconnection
0002from . import sqlbuilder
0003from .compat import string_type
0004
0005
0006__all__ = ['SelectResults']
0007
0008
0009class SelectResults(object):
0010    IterationClass = dbconnection.Iteration
0011
0012    def __init__(self, sourceClass, clause, clauseTables=None,
0013                 **ops):
0014        self.sourceClass = sourceClass
0015        if clause is None or isinstance(clause, str) and clause == 'all':
0016            clause = sqlbuilder.SQLTrueClause
0017        if not isinstance(clause, sqlbuilder.SQLExpression):
0018            clause = sqlbuilder.SQLConstant(clause)
0019        self.clause = clause
0020        self.ops = ops
0021        if ops.get('orderBy', sqlbuilder.NoDefault) is sqlbuilder.NoDefault:
0022            ops['orderBy'] = sourceClass.sqlmeta.defaultOrder
0023        orderBy = ops['orderBy']
0024        if isinstance(orderBy, (tuple, list)):
0025            orderBy = list(map(self._mungeOrderBy, orderBy))
0026        else:
0027            orderBy = self._mungeOrderBy(orderBy)
0028        ops['dbOrderBy'] = orderBy
0029        if 'connection' in ops and ops['connection'] is None:
0030            del ops['connection']
0031        if ops.get('limit', None):
0032            assert not ops.get('start', None) and not ops.get('end', None),                   "'limit' cannot be used with 'start' or 'end'"
0034            ops["start"] = 0
0035            ops["end"] = ops.pop("limit")
0036
0037        tablesSet = sqlbuilder.tablesUsedSet(self.clause,
0038                                             self._getConnection().dbName)
0039        if clauseTables:
0040            for table in clauseTables:
0041                tablesSet.add(table)
0042        self.clauseTables = clauseTables
0043        # Explicitly post-adding-in sqlmeta.table,
0044        # sqlbuilder.Select will handle sqlrepr'ing and dupes.
0045        self.tables = list(tablesSet) + [sourceClass.sqlmeta.table]
0046
0047    def queryForSelect(self):
0048        columns = [self.sourceClass.q.id] +               [getattr(self.sourceClass.q, x.name)
0050             for x in self.sourceClass.sqlmeta.columnList]
0051        query = sqlbuilder.Select(columns,
0052                                  where=self.clause,
0053                                  join=self.ops.get(
0054                                      'join', sqlbuilder.NoDefault),
0055                                  distinct=self.ops.get('distinct', False),
0056                                  lazyColumns=self.ops.get(
0057                                      'lazyColumns', False),
0058                                  start=self.ops.get('start', 0),
0059                                  end=self.ops.get('end', None),
0060                                  orderBy=self.ops.get(
0061                                      'dbOrderBy', sqlbuilder.NoDefault),
0062                                  reversed=self.ops.get('reversed', False),
0063                                  staticTables=self.tables,
0064                                  forUpdate=self.ops.get('forUpdate', False))
0065        return query
0066
0067    def __repr__(self):
0068        return "<%s at %x>" % (self.__class__.__name__, id(self))
0069
0070    def _getConnection(self):
0071        return self.ops.get('connection') or self.sourceClass._connection
0072
0073    def __str__(self):
0074        conn = self._getConnection()
0075        return conn.queryForSelect(self)
0076
0077    def _mungeOrderBy(self, orderBy):
0078        if isinstance(orderBy, string_type) and orderBy.startswith('-'):
0079            orderBy = orderBy[1:]
0080            desc = True
0081        else:
0082            desc = False
0083        if isinstance(orderBy, string_type):
0084            if orderBy in self.sourceClass.sqlmeta.columns:
0085                val = getattr(self.sourceClass.q,
0086                              self.sourceClass.sqlmeta.columns[orderBy].name)
0087                if desc:
0088                    return sqlbuilder.DESC(val)
0089                else:
0090                    return val
0091            else:
0092                orderBy = sqlbuilder.SQLConstant(orderBy)
0093                if desc:
0094                    return sqlbuilder.DESC(orderBy)
0095                else:
0096                    return orderBy
0097        else:
0098            return orderBy
0099
0100    def clone(self, **newOps):
0101        ops = self.ops.copy()
0102        ops.update(newOps)
0103        return self.__class__(self.sourceClass, self.clause,
0104                              self.clauseTables, **ops)
0105
0106    def orderBy(self, orderBy):
0107        return self.clone(orderBy=orderBy)
0108
0109    def connection(self, conn):
0110        return self.clone(connection=conn)
0111
0112    def limit(self, limit):
0113        return self[:limit]
0114
0115    def lazyColumns(self, value):
0116        return self.clone(lazyColumns=value)
0117
0118    def reversed(self):
0119        return self.clone(reversed=not self.ops.get('reversed', False))
0120
0121    def distinct(self):
0122        return self.clone(distinct=True)
0123
0124    def newClause(self, new_clause):
0125        return self.__class__(self.sourceClass, new_clause,
0126                              self.clauseTables, **self.ops)
0127
0128    def filter(self, filter_clause):
0129        if filter_clause is None:
0130            # None doesn't filter anything, it's just a no-op:
0131            return self
0132        clause = self.clause
0133        if isinstance(clause, string_type):
0134            clause = sqlbuilder.SQLConstant('(%s)' % clause)
0135        return self.newClause(sqlbuilder.AND(clause, filter_clause))
0136
0137    def __getitem__(self, value):
0138        if isinstance(value, slice):
0139            assert not value.step, "Slices do not support steps"
0140            if not value.start and not value.stop:
0141                # No need to copy, I'm immutable
0142                return self
0143
0144            # Negative indexes aren't handled (and everything we
0145            # don't handle ourselves we just create a list to
0146            # handle)
0147            if (value.start and value.start < 0)                  or (value.stop and value.stop < 0):
0149                if value.start:
0150                    if value.stop:
0151                        return list(self)[value.start:value.stop]
0152                    return list(self)[value.start:]
0153                return list(self)[:value.stop]
0154
0155            if value.start:
0156                assert value.start >= 0
0157                start = self.ops.get('start', 0) + value.start
0158                if value.stop is not None:
0159                    assert value.stop >= 0
0160                    if value.stop < value.start:
0161                        # an empty result:
0162                        end = start
0163                    else:
0164                        end = value.stop + self.ops.get('start', 0)
0165                        if self.ops.get('end', None) is not None and                                   self.ops['end'] < end:
0167                            # truncated by previous slice:
0168                            end = self.ops['end']
0169                else:
0170                    end = self.ops.get('end', None)
0171            else:
0172                start = self.ops.get('start', 0)
0173                end = value.stop + start
0174                if self.ops.get('end', None) is not None                      and self.ops['end'] < end:
0176                    end = self.ops['end']
0177            return self.clone(start=start, end=end)
0178        else:
0179            if value < 0:
0180                return list(iter(self))[value]
0181            else:
0182                start = self.ops.get('start', 0) + value
0183                return list(self.clone(start=start, end=start + 1))[0]
0184
0185    def __iter__(self):
0186        # @@: This could be optimized, using a simpler algorithm
0187        # since we don't have to worry about garbage collection,
0188        # etc., like we do with .lazyIter()
0189        return iter(list(self.lazyIter()))
0190
0191    def lazyIter(self):
0192        """
0193        Returns an iterator that will lazily pull rows out of the
0194        database and return SQLObject instances
0195        """
0196        conn = self._getConnection()
0197        return conn.iterSelect(self)
0198
0199    def accumulate(self, *expressions):
0200        """ Use accumulate expression(s) to select result
0201            using another SQL select through current
0202            connection.
0203            Return the accumulate result
0204        """
0205        conn = self._getConnection()
0206        exprs = []
0207        for expr in expressions:
0208            if not isinstance(expr, sqlbuilder.SQLExpression):
0209                expr = sqlbuilder.SQLConstant(expr)
0210            exprs.append(expr)
0211        return conn.accumulateSelect(self, *exprs)
0212
0213    def count(self):
0214        """ Counting elements of current select results """
0215        assert not self.ops.get('start') and not self.ops.get('end'),               "start/end/limit have no meaning with 'count'"
0217        assert not (self.ops.get('distinct') and
0218                    (self.ops.get('start') or self.ops.get('end'))),               "distinct-counting of sliced objects is not supported"
0220        if self.ops.get('distinct'):
0221            # Column must be specified, so we are using unique ID column.
0222            # COUNT(DISTINCT column) is supported by MySQL and PostgreSQL,
0223            # but not by SQLite. Perhaps more portable would be subquery:
0224            #  SELECT COUNT(*) FROM (SELECT DISTINCT id FROM table)
0225            count = self.accumulate(
0226                'COUNT(DISTINCT %s)' % self._getConnection().sqlrepr(
0227                    self.sourceClass.q.id))
0228        else:
0229            count = self.accumulate('COUNT(*)')
0230        if self.ops.get('start'):
0231            count -= self.ops['start']
0232        if self.ops.get('end'):
0233            count = min(self.ops['end'] - self.ops.get('start', 0), count)
0234        return count
0235
0236    def accumulateMany(self, *attributes):
0237        """ Making the expressions for count/sum/min/max/avg
0238            of a given select result attributes.
0239            `attributes` must be a list/tuple of pairs (func_name, attribute);
0240            `attribute` can be a column name (like 'a_column')
0241            or a dot-q attribute (like Table.q.aColumn)
0242        """
0243        expressions = []
0244        conn = self._getConnection()
0245        if self.ops.get('distinct'):
0246            distinct = 'DISTINCT '
0247        else:
0248            distinct = ''
0249        for func_name, attribute in attributes:
0250            if not isinstance(attribute, str):
0251                attribute = conn.sqlrepr(attribute)
0252            expression = '%s(%s%s)' % (func_name, distinct, attribute)
0253            expressions.append(expression)
0254        return self.accumulate(*expressions)
0255
0256    def accumulateOne(self, func_name, attribute):
0257        """ Making the sum/min/max/avg of a given select result attribute.
0258            `attribute` can be a column name (like 'a_column')
0259            or a dot-q attribute (like Table.q.aColumn)
0260        """
0261        return self.accumulateMany((func_name, attribute))
0262
0263    def sum(self, attribute):
0264        return self.accumulateOne("SUM", attribute)
0265
0266    def min(self, attribute):
0267        return self.accumulateOne("MIN", attribute)
0268
0269    def avg(self, attribute):
0270        return self.accumulateOne("AVG", attribute)
0271
0272    def max(self, attribute):
0273        return self.accumulateOne("MAX", attribute)
0274
0275    def getOne(self, default=sqlbuilder.NoDefault):
0276        """
0277        If a query is expected to only return a single value,
0278        using ``.getOne()`` will return just that value.
0279
0280        If not results are found, ``SQLObjectNotFound`` will be
0281        raised, unless you pass in a default value (like
0282        ``.getOne(None)``).
0283
0284        If more than one result is returned,
0285        ``SQLObjectIntegrityError`` will be raised.
0286        """
0287        from . import main
0288        results = list(self)
0289        if not results:
0290            if default is sqlbuilder.NoDefault:
0291                raise main.SQLObjectNotFound(
0292                    "No results matched the query for %s"
0293                    % self.sourceClass.__name__)
0294            return default
0295        if len(results) > 1:
0296            raise main.SQLObjectIntegrityError(
0297                "More than one result returned from query: %s"
0298                % results)
0299        return results[0]
0300
0301    def throughTo(self):
0302        class _throughTo_getter(object):
0303            def __init__(self, inst):
0304                self.sresult = inst
0305
0306            def __getattr__(self, attr):
0307                return self.sresult._throughTo(attr)
0308        return _throughTo_getter(self)
0309    throughTo = property(throughTo)
0310
0311    def _throughTo(self, attr):
0312        otherClass = None
0313        orderBy = sqlbuilder.NoDefault
0314
0315        ref = self.sourceClass.sqlmeta.columns.get(
0316            attr.endswith('ID') and attr or attr + 'ID', None)
0317        if ref and ref.foreignKey:
0318            otherClass, clause = self._throughToFK(ref)
0319        else:
0320            join = [x for x in self.sourceClass.sqlmeta.joins
0321                    if x.joinMethodName == attr]
0322            if join:
0323                join = join[0]
0324                orderBy = join.orderBy
0325                if hasattr(join, 'otherColumn'):
0326                    otherClass, clause = self._throughToRelatedJoin(join)
0327                else:
0328                    otherClass, clause = self._throughToMultipleJoin(join)
0329
0330        if not otherClass:
0331            raise AttributeError(
0332                "throughTo argument (got %s) should be "
0333                "name of foreignKey or SQL*Join in %s" % (attr,
0334                                                          self.sourceClass))
0335
0336        return otherClass.select(clause,
0337                                 orderBy=orderBy,
0338                                 connection=self._getConnection())
0339
0340    def _throughToFK(self, col):
0341        otherClass = getattr(self.sourceClass, "_SO_class_" + col.foreignKey)
0342        colName = col.name
0343        query = self.queryForSelect().newItems([
0344            sqlbuilder.ColumnAS(getattr(self.sourceClass.q, colName), colName)
0345        ]).orderBy(None).distinct()
0346        query = sqlbuilder.Alias(query,
0347                                 "%s_%s" % (self.sourceClass.__name__,
0348                                            col.name))
0349        return otherClass, otherClass.q.id == getattr(query.q, colName)
0350
0351    def _throughToMultipleJoin(self, join):
0352        otherClass = join.otherClass
0353        colName = join.soClass.sqlmeta.style.              dbColumnToPythonAttr(join.joinColumn)
0355        query = self.queryForSelect().newItems(
0356            [sqlbuilder.ColumnAS(self.sourceClass.q.id, 'id')]).              orderBy(None).distinct()
0358        query = sqlbuilder.Alias(query,
0359                                 "%s_%s" % (self.sourceClass.__name__,
0360                                            join.joinMethodName))
0361        joinColumn = getattr(otherClass.q, colName)
0362        return otherClass, joinColumn == query.q.id
0363
0364    def _throughToRelatedJoin(self, join):
0365        otherClass = join.otherClass
0366        intTable = sqlbuilder.Table(join.intermediateTable)
0367        colName = join.joinColumn
0368        query = self.queryForSelect().newItems(
0369            [sqlbuilder.ColumnAS(self.sourceClass.q.id, 'id')]).              orderBy(None).distinct()
0371        query = sqlbuilder.Alias(query,
0372                                 "%s_%s" % (self.sourceClass.__name__,
0373                                            join.joinMethodName))
0374        clause = sqlbuilder.AND(
0375            otherClass.q.id == getattr(intTable, join.otherColumn),
0376            getattr(intTable, colName) == query.q.id)
0377        return otherClass, clause
SQLObject-3.1.0/docs/html/sqlobject/firebird/0000755000175000017500000000000012754657361020341 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/firebird/__init__.py.html0000644000175000017500000000740112464733165023412 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/firebird/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import firebirdconnection
0006    return firebirdconnection.FirebirdConnection
0007
0008registerConnection(['firebird', 'interbase'], builder)
SQLObject-3.1.0/docs/html/sqlobject/sybase/0000755000175000017500000000000012754657361020041 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/sybase/__init__.py.html0000644000175000017500000000726012464733165023115 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/sybase/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import sybaseconnection
0006    return sybaseconnection.SybaseConnection
0007
0008registerConnection(['sybase'], builder)
SQLObject-3.1.0/docs/html/sqlobject/sqlite/0000755000175000017500000000000012754657361020054 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/sqlite/__init__.py.html0000644000175000017500000000726012464733165023130 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/sqlite/__init__.py
0001from sqlobject.dbconnection import registerConnection
0002
0003
0004def builder():
0005    from . import sqliteconnection
0006    return sqliteconnection.SQLiteConnection
0007
0008registerConnection(['sqlite'], builder)
SQLObject-3.1.0/docs/html/sqlobject/styles.py.html0000644000175000017500000011764412463427161021416 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/styles.py
0001import re
0002
0003
0004__all__ = ["Style", "MixedCaseUnderscoreStyle", "DefaultStyle",
0005           "MixedCaseStyle"]
0006
0007
0008class Style(object):
0009
0010    """
0011    The base Style class, and also the simplest implementation.  No
0012    translation occurs -- column names and attribute names match,
0013    as do class names and table names (when using auto class or
0014    schema generation).
0015    """
0016
0017    def __init__(self, pythonAttrToDBColumn=None,
0018                 dbColumnToPythonAttr=None,
0019                 pythonClassToDBTable=None,
0020                 dbTableToPythonClass=None,
0021                 idForTable=None,
0022                 longID=False):
0023        if pythonAttrToDBColumn:
0024            self.pythonAttrToDBColumn =                   lambda a, s=self: pythonAttrToDBColumn(s, a)
0026        if dbColumnToPythonAttr:
0027            self.dbColumnToPythonAttr =                   lambda a, s=self: dbColumnToPythonAttr(s, a)
0029        if pythonClassToDBTable:
0030            self.pythonClassToDBTable =                   lambda a, s=self: pythonClassToDBTable(s, a)
0032        if dbTableToPythonClass:
0033            self.dbTableToPythonClass =                   lambda a, s=self: dbTableToPythonClass(s, a)
0035        if idForTable:
0036            self.idForTable = lambda a, s=self: idForTable(s, a)
0037        self.longID = longID
0038
0039    def pythonAttrToDBColumn(self, attr):
0040        return attr
0041
0042    def dbColumnToPythonAttr(self, col):
0043        return col
0044
0045    def pythonClassToDBTable(self, className):
0046        return className
0047
0048    def dbTableToPythonClass(self, table):
0049        return table
0050
0051    def idForTable(self, table):
0052        if self.longID:
0053            return self.tableReference(table)
0054        else:
0055            return 'id'
0056
0057    def pythonClassToAttr(self, className):
0058        return lowerword(className)
0059
0060    def instanceAttrToIDAttr(self, attr):
0061        return attr + "ID"
0062
0063    def instanceIDAttrToAttr(self, attr):
0064        return attr[:-2]
0065
0066    def tableReference(self, table):
0067        return table + "_id"
0068
0069
0070class MixedCaseUnderscoreStyle(Style):
0071
0072    """
0073    This is the default style.  Python attributes use mixedCase,
0074    while database columns use underscore_separated.
0075    """
0076
0077    def pythonAttrToDBColumn(self, attr):
0078        return mixedToUnder(attr)
0079
0080    def dbColumnToPythonAttr(self, col):
0081        return underToMixed(col)
0082
0083    def pythonClassToDBTable(self, className):
0084        return className[0].lower()               + mixedToUnder(className[1:])
0086
0087    def dbTableToPythonClass(self, table):
0088        return table[0].upper()               + underToMixed(table[1:])
0090
0091    def pythonClassToDBTableReference(self, className):
0092        return self.tableReference(self.pythonClassToDBTable(className))
0093
0094    def tableReference(self, table):
0095        return table + "_id"
0096
0097DefaultStyle = MixedCaseUnderscoreStyle
0098
0099
0100class MixedCaseStyle(Style):
0101
0102    """
0103    This style leaves columns as mixed-case, and uses long
0104    ID names (like ProductID instead of simply id).
0105    """
0106
0107    def pythonAttrToDBColumn(self, attr):
0108        return capword(attr)
0109
0110    def dbColumnToPythonAttr(self, col):
0111        return lowerword(col)
0112
0113    def dbTableToPythonClass(self, table):
0114        return capword(table)
0115
0116    def tableReference(self, table):
0117        return table + "ID"
0118
0119defaultStyle = DefaultStyle()
0120
0121
0122def getStyle(soClass, dbConnection=None):
0123    if dbConnection is None:
0124        if hasattr(soClass, '_connection'):
0125            dbConnection = soClass._connection
0126    if hasattr(soClass.sqlmeta, 'style') and soClass.sqlmeta.style:
0127        return soClass.sqlmeta.style
0128    elif dbConnection and dbConnection.style:
0129        return dbConnection.style
0130    else:
0131        return defaultStyle
0132
0133
0134############################################################
0135# Text utilities
0136############################################################
0137
0138
0139_mixedToUnderRE = re.compile(r'[A-Z]+')
0140
0141
0142def mixedToUnder(s):
0143    if s.endswith('ID'):
0144        return mixedToUnder(s[:-2] + "_id")
0145    trans = _mixedToUnderRE.sub(mixedToUnderSub, s)
0146    if trans.startswith('_'):
0147        trans = trans[1:]
0148    return trans
0149
0150
0151def mixedToUnderSub(match):
0152    m = match.group(0).lower()
0153    if len(m) > 1:
0154        return '_%s_%s' % (m[:-1], m[-1])
0155    else:
0156        return '_%s' % m
0157
0158
0159def capword(s):
0160    return s[0].upper() + s[1:]
0161
0162
0163def lowerword(s):
0164    return s[0].lower() + s[1:]
0165
0166
0167_underToMixedRE = re.compile('_.')
0168
0169
0170def underToMixed(name):
0171    if name.endswith('_id'):
0172        return underToMixed(name[:-3] + "ID")
0173    return _underToMixedRE.sub(lambda m: m.group(0)[1].upper(),
0174                               name)
SQLObject-3.1.0/docs/html/sqlobject/boundattributes.py.html0000644000175000017500000007427712470110264023304 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/boundattributes.py
0001"""
0002Bound attributes are attributes that are bound to a specific class and
0003a specific name.  In SQLObject a typical example is a column object,
0004which knows its name and class.
0005
0006A bound attribute should define a method ``__addtoclass__(added_class,
0007name)`` (attributes without this method will simply be treated as
0008normal).  The return value is ignored; if the attribute wishes to
0009change the value in the class, it must call ``setattr(added_class,
0010name, new_value)``.
0011
0012BoundAttribute is a class that facilitates lazy attribute creation.
0013"""
0014from __future__ import absolute_import
0015
0016from . import declarative
0017from . import events
0018
0019__all__ = ['BoundAttribute', 'BoundFactory']
0020
0021
0022class BoundAttribute(declarative.Declarative):
0023
0024    """
0025    This is a declarative class that passes all the values given to it
0026    to another object.  So you can pass it arguments (via
0027    __init__/__call__) or give it the equivalent of keyword arguments
0028    through subclassing.  Then a bound object will be added in its
0029    place.
0030
0031    To hook this other object in, override ``make_object(added_class,
0032    name, **attrs)`` and maybe ``set_object(added_class, name,
0033    **attrs)`` (the default implementation of ``set_object``
0034    just resets the attribute to whatever ``make_object`` returned).
0035
0036    Also see ``BoundFactory``.
0037    """
0038
0039    _private_variables = (
0040        '_private_variables',
0041        '_all_attributes',
0042        '__classinit__',
0043        '__addtoclass__',
0044        '_add_attrs',
0045        'set_object',
0046        'make_object',
0047        'clone_in_subclass',
0048    )
0049
0050    _all_attrs = ()
0051    clone_for_subclass = True
0052
0053    def __classinit__(cls, new_attrs):
0054        declarative.Declarative.__classinit__(cls, new_attrs)
0055        cls._all_attrs = cls._add_attrs(cls, new_attrs)
0056
0057    def __instanceinit__(self, new_attrs):
0058        declarative.Declarative.__instanceinit__(self, new_attrs)
0059        self.__dict__['_all_attrs'] = self._add_attrs(self, new_attrs)
0060
0061    @staticmethod
0062    def _add_attrs(this_object, new_attrs):
0063        private = this_object._private_variables
0064        all_attrs = list(this_object._all_attrs)
0065        for key in new_attrs.keys():
0066            if key.startswith('_') or key in private:
0067                continue
0068            if key not in all_attrs:
0069                all_attrs.append(key)
0070        return tuple(all_attrs)
0071
0072    @declarative.classinstancemethod
0073    def __addtoclass__(self, cls, added_class, attr_name):
0074        me = self or cls
0075        attrs = {}
0076        for name in me._all_attrs:
0077            attrs[name] = getattr(me, name)
0078        attrs['added_class'] = added_class
0079        attrs['attr_name'] = attr_name
0080        obj = me.make_object(**attrs)
0081
0082        if self.clone_for_subclass:
0083            def on_rebind(new_class_name, bases, new_attrs,
0084                          post_funcs, early_funcs):
0085                def rebind(new_class):
0086                    me.set_object(
0087                        new_class, attr_name,
0088                        me.make_object(**attrs))
0089                post_funcs.append(rebind)
0090            events.listen(receiver=on_rebind, soClass=added_class,
0091                          signal=events.ClassCreateSignal, weak=False)
0092
0093        me.set_object(added_class, attr_name, obj)
0094
0095    @classmethod
0096    def set_object(cls, added_class, attr_name, obj):
0097        setattr(added_class, attr_name, obj)
0098
0099    @classmethod
0100    def make_object(cls, added_class, attr_name, *args, **attrs):
0101        raise NotImplementedError
0102
0103    def __setattr__(self, name, value):
0104        self.__dict__['_all_attrs'] = self._add_attrs(self, {name: value})
0105        self.__dict__[name] = value
0106
0107
0108class BoundFactory(BoundAttribute):
0109
0110    """
0111    This will bind the attribute to whatever is given by
0112    ``factory_class``.  This factory should be a callable with the
0113    signature ``factory_class(added_class, attr_name, *args, **kw)``.
0114
0115    The factory will be reinvoked (and the attribute rebound) for
0116    every subclassing.
0117    """
0118
0119    factory_class = None
0120    _private_variables = (
0121        BoundAttribute._private_variables + ('factory_class',))
0122
0123    def make_object(cls, added_class, attr_name, *args, **kw):
0124        return cls.factory_class(added_class, attr_name, *args, **kw)
SQLObject-3.1.0/docs/html/sqlobject/declarative.py.html0000644000175000017500000016365612471371300022352 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/declarative.py
0001"""
0002Declarative objects.
0003
0004Declarative objects have a simple protocol: you can use classes in
0005lieu of instances and they are equivalent, and any keyword arguments
0006you give to the constructor will override those instance variables.
0007(So if a class is received, we'll simply instantiate an instance with
0008no arguments).
0009
0010You can provide a variable __unpackargs__ (a list of strings), and if
0011the constructor is called with non-keyword arguments they will be
0012interpreted as the given keyword arguments.
0013
0014If __unpackargs__ is ('*', name), then all the arguments will be put
0015in a variable by that name.
0016
0017You can define a __classinit__(cls, new_attrs) method, which will be
0018called when the class is created (including subclasses).  Note: you
0019can't use super() in __classinit__ because the class isn't bound to a
0020name.  As an analog to __classinit__, Declarative adds
0021__instanceinit__ which is called with the same argument (new_attrs).
0022This is like __init__, but after __unpackargs__ and other factors have
0023been taken into account.
0024
0025If __mutableattributes__ is defined as a sequence of strings, these
0026attributes will not be shared between superclasses and their
0027subclasses.  E.g., if you have a class variable that contains a list
0028and you append to that list, changes to subclasses will effect
0029superclasses unless you add the attribute here.
0030
0031Also defines classinstancemethod, which acts as either a class method
0032or an instance method depending on where it is called.
0033"""
0034
0035import copy
0036from . import events
0037from sqlobject.compat import with_metaclass
0038
0039import itertools
0040counter = itertools.count()
0041
0042__all__ = ('classinstancemethod', 'DeclarativeMeta', 'Declarative')
0043
0044
0045class classinstancemethod(object):
0046    """
0047    Acts like a class method when called from a class, like an
0048    instance method when called by an instance.  The method should
0049    take two arguments, 'self' and 'cls'; one of these will be None
0050    depending on how the method was called.
0051    """
0052
0053    def __init__(self, func):
0054        self.func = func
0055
0056    def __get__(self, obj, type=None):
0057        return _methodwrapper(self.func, obj=obj, type=type)
0058
0059
0060class _methodwrapper(object):
0061
0062    def __init__(self, func, obj, type):
0063        self.func = func
0064        self.obj = obj
0065        self.type = type
0066
0067    def __call__(self, *args, **kw):
0068        assert 'self' not in kw and 'cls' not in kw, (
0069            "You cannot use 'self' or 'cls' arguments to a "
0070            "classinstancemethod")
0071        return self.func(*((self.obj, self.type) + args), **kw)
0072
0073    def __repr__(self):
0074        if self.obj is None:
0075            return ('<bound class method %s.%s>'
0076                    % (self.type.__name__, self.func.__name__))
0077        else:
0078            return ('<bound method %s.%s of %r>'
0079                    % (self.type.__name__, self.func.__name__, self.obj))
0080
0081
0082class DeclarativeMeta(type):
0083
0084    def __new__(meta, class_name, bases, new_attrs):
0085        post_funcs = []
0086        early_funcs = []
0087        events.send(events.ClassCreateSignal,
0088                    bases[0], class_name, bases, new_attrs,
0089                    post_funcs, early_funcs)
0090        cls = type.__new__(meta, class_name, bases, new_attrs)
0091        for func in early_funcs:
0092            func(cls)
0093        if '__classinit__' in new_attrs:
0094            if hasattr(cls.__classinit__, '__func__'):
0095                cls.__classinit__ = staticmethod(cls.__classinit__.__func__)
0096            else:
0097                cls.__classinit__ = staticmethod(cls.__classinit__)
0098        cls.__classinit__(cls, new_attrs)
0099        for func in post_funcs:
0100            func(cls)
0101        return cls
0102
0103
0104class Declarative(with_metaclass(DeclarativeMeta, object)):
0105
0106    __unpackargs__ = ()
0107
0108    __mutableattributes__ = ()
0109
0110    __restrict_attributes__ = None
0111
0112    def __classinit__(cls, new_attrs):
0113        cls.declarative_count = next(counter)
0114        for name in cls.__mutableattributes__:
0115            if name not in new_attrs:
0116                setattr(cls, copy.copy(getattr(cls, name)))
0117
0118    def __instanceinit__(self, new_attrs):
0119        if self.__restrict_attributes__ is not None:
0120            for name in new_attrs:
0121                if name not in self.__restrict_attributes__:
0122                    raise TypeError(
0123                        '%s() got an unexpected keyword argument %r'
0124                        % (self.__class__.__name__, name))
0125        for name, value in new_attrs.items():
0126            setattr(self, name, value)
0127        if 'declarative_count' not in new_attrs:
0128            self.declarative_count = next(counter)
0129
0130    def __init__(self, *args, **kw):
0131        if self.__unpackargs__ and self.__unpackargs__[0] == '*':
0132            assert len(self.__unpackargs__) == 2,                   "When using __unpackargs__ = ('*', varname), "                   "you must only provide a single variable name "                   "(you gave %r)" % self.__unpackargs__
0136            name = self.__unpackargs__[1]
0137            if name in kw:
0138                raise TypeError(
0139                    "keyword parameter '%s' was given by position and name"
0140                    % name)
0141            kw[name] = args
0142        else:
0143            if len(args) > len(self.__unpackargs__):
0144                raise TypeError(
0145                    '%s() takes at most %i arguments (%i given)'
0146                    % (self.__class__.__name__,
0147                       len(self.__unpackargs__),
0148                       len(args)))
0149            for name, arg in zip(self.__unpackargs__, args):
0150                if name in kw:
0151                    raise TypeError(
0152                        "keyword parameter '%s' was given by position and name"
0153                        % name)
0154                kw[name] = arg
0155        if '__alsocopy' in kw:
0156            for name, value in kw['__alsocopy'].items():
0157                if name not in kw:
0158                    if name in self.__mutableattributes__:
0159                        value = copy.copy(value)
0160                    kw[name] = value
0161            del kw['__alsocopy']
0162        self.__instanceinit__(kw)
0163
0164    def __call__(self, *args, **kw):
0165        kw['__alsocopy'] = self.__dict__
0166        return self.__class__(*args, **kw)
0167
0168    @classinstancemethod
0169    def singleton(self, cls):
0170        if self:
0171            return self
0172        name = '_%s__singleton' % cls.__name__
0173        if not hasattr(cls, name):
0174            setattr(cls, name, cls(declarative_count=cls.declarative_count))
0175        return getattr(cls, name)
0176
0177    @classinstancemethod
0178    def __repr__(self, cls):
0179        if self:
0180            name = '%s object' % self.__class__.__name__
0181            v = self.__dict__.copy()
0182        else:
0183            name = '%s class' % cls.__name__
0184            v = cls.__dict__.copy()
0185        if 'declarative_count' in v:
0186            name = '%s %i' % (name, v['declarative_count'])
0187            del v['declarative_count']
0188        # @@: simplifying repr:
0189        # v = {}
0190        names = v.keys()
0191        args = []
0192        for n in self._repr_vars(names):
0193            args.append('%s=%r' % (n, v[n]))
0194        if not args:
0195            return '<%s>' % name
0196        else:
0197            return '<%s %s>' % (name, ' '.join(args))
0198
0199    @staticmethod
0200    def _repr_vars(dictNames):
0201        names = [n for n in dictNames
0202                 if not n.startswith('_') and
0203                 n != 'declarative_count']
0204        names.sort()
0205        return names
0206
0207
0208def setup_attributes(cls, new_attrs):
0209    for name, value in new_attrs.items():
0210        if hasattr(value, '__addtoclass__'):
0211            value.__addtoclass__(cls, name)
SQLObject-3.1.0/docs/html/sqlobject/cache.py.html0000644000175000017500000027501512471371300021123 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/cache.py
0001"""
0002This implements the instance caching in SQLObject.  Caching is
0003relatively aggressive.  All objects are retained so long as they are
0004in memory, by keeping weak references to objects.  We also keep other
0005objects in a cache that doesn't allow them to be garbage collected
0006(unless caching is turned off).
0007"""
0008
0009import threading
0010from weakref import ref
0011
0012
0013class CacheFactory(object):
0014
0015    """
0016    CacheFactory caches object creation.  Each object should be
0017    referenced by a single hashable ID (note tuples of hashable
0018    values are also hashable).
0019
0020    """
0021
0022    def __init__(self, cullFrequency=100, cullFraction=2,
0023                 cache=True):
0024        """
0025        Every cullFrequency times that an item is retrieved from
0026        this cache, the cull method is called.
0027
0028        The cull method then expires an arbitrary fraction of
0029        the cached objects.  The idea is at no time will the cache
0030        be entirely emptied, placing a potentially high load at that
0031        moment, but everything object will have its time to go
0032        eventually.  The fraction is given as an integer, and one
0033        in that many objects are expired (i.e., the default is 1/2
0034        of objects are expired).
0035
0036        By setting cache to False, items won't be cached.
0037
0038        However, in all cases a weak reference is kept to created
0039        objects, and if the object hasn't been garbage collected
0040        it will be returned.
0041        """
0042
0043        self.cullFrequency = cullFrequency
0044        self.cullCount = 0
0045        self.cullOffset = 0
0046        self.cullFraction = cullFraction
0047        self.doCache = cache
0048
0049        if self.doCache:
0050            self.cache = {}
0051        self.expiredCache = {}
0052        self.lock = threading.Lock()
0053
0054    def tryGet(self, id):
0055        """
0056        This returns None, or the object in cache.
0057        """
0058        value = self.expiredCache.get(id)
0059        if value:
0060            # it's actually a weakref:
0061            return value()
0062        if not self.doCache:
0063            return None
0064        return self.cache.get(id)
0065
0066    def get(self, id):
0067        """
0068        This method can cause deadlocks!  tryGet is safer
0069
0070        This returns the object found in cache, or None.  If None,
0071        then the cache will remain locked!  This is so that the
0072        calling function can create the object in a threadsafe manner
0073        before releasing the lock.  You should use this like (note
0074        that ``cache`` is actually a CacheSet object in this
0075        example)::
0076
0077          obj = cache.get(some_id, my_class)
0078          if obj is None:
0079              try:
0080                  obj = create_object(some_id)
0081                  cache.put(some_id, my_class, obj)
0082              finally:
0083                  cache.finishPut(cls)
0084
0085        This method checks both the main cache (which retains
0086        references) and the 'expired' cache, which retains only weak
0087        references.
0088        """
0089
0090        if self.doCache:
0091            if self.cullCount > self.cullFrequency:
0092                # Two threads could hit the cull in a row, but
0093                # that's not so bad.  At least by setting cullCount
0094                # back to zero right away we avoid this.  The cull
0095                # method has a lock, so it's threadsafe.
0096                self.cullCount = 0
0097                self.cull()
0098            else:
0099                self.cullCount = self.cullCount + 1
0100
0101            try:
0102                return self.cache[id]
0103            except KeyError:
0104                pass
0105            self.lock.acquire()
0106            try:
0107                val = self.cache[id]
0108            except KeyError:
0109                pass
0110            else:
0111                self.lock.release()
0112                return val
0113            try:
0114                val = self.expiredCache[id]()
0115            except KeyError:
0116                return None
0117            else:
0118                del self.expiredCache[id]
0119                if val is None:
0120                    return None
0121            self.cache[id] = val
0122            self.lock.release()
0123            return val
0124
0125        else:
0126            try:
0127                val = self.expiredCache[id]()
0128                if val is not None:
0129                    return val
0130            except KeyError:
0131                pass
0132            self.lock.acquire()
0133            try:
0134                val = self.expiredCache[id]()
0135            except KeyError:
0136                return None
0137            else:
0138                if val is None:
0139                    del self.expiredCache[id]
0140                    return None
0141            self.lock.release()
0142            return val
0143
0144    def put(self, id, obj):
0145        """
0146        Puts an object into the cache.  Should only be called after
0147        .get(), so that duplicate objects don't end up in the cache.
0148        """
0149        if self.doCache:
0150            self.cache[id] = obj
0151        else:
0152            self.expiredCache[id] = ref(obj)
0153
0154    def finishPut(self):
0155        """
0156        Releases the lock that is retained when .get() is called and
0157        returns None.
0158        """
0159        self.lock.release()
0160
0161    def created(self, id, obj):
0162        """
0163        Inserts and object into the cache.  Should be used when no one
0164        else knows about the object yet, so there cannot be any object
0165        already in the cache.  After a database INSERT is an example
0166        of this situation.
0167        """
0168        if self.doCache:
0169            if self.cullCount > self.cullFrequency:
0170                # Two threads could hit the cull in a row, but
0171                # that's not so bad.  At least by setting cullCount
0172                # back to zero right away we avoid this.  The cull
0173                # method has a lock, so it's threadsafe.
0174                self.cullCount = 0
0175                self.cull()
0176            else:
0177                self.cullCount = self.cullCount + 1
0178            self.cache[id] = obj
0179        else:
0180            self.expiredCache[id] = ref(obj)
0181
0182    def cull(self):
0183        """Runs through the cache and expires objects
0184
0185        E.g., if ``cullFraction`` is 3, then every third object is moved to
0186        the 'expired' (aka weakref) cache.
0187
0188        """
0189        self.lock.acquire()
0190        try:
0191            # remove dead references from the expired cache
0192            keys = list(self.expiredCache.keys())
0193            for key in keys:
0194                if self.expiredCache[key]() is None:
0195                    self.expiredCache.pop(key, None)
0196
0197            keys = list(self.cache.keys())
0198            for i in range(self.cullOffset, len(keys), self.cullFraction):
0199                id = keys[i]
0200                # create a weakref, then remove from the cache
0201                obj = ref(self.cache[id])
0202                del self.cache[id]
0203
0204                # the object may have been gc'd when removed from the cache
0205                # above, no need to place in expiredCache
0206                if obj() is not None:
0207                    self.expiredCache[id] = obj
0208            # This offset tries to balance out which objects we
0209            # expire, so no object will just hang out in the cache
0210            # forever.
0211            self.cullOffset = (self.cullOffset + 1) % self.cullFraction
0212        finally:
0213            self.lock.release()
0214
0215    def clear(self):
0216        """
0217        Removes everything from the cache.  Warning!  This can cause
0218        duplicate objects in memory.
0219        """
0220        if self.doCache:
0221            self.cache.clear()
0222        self.expiredCache.clear()
0223
0224    def expire(self, id):
0225        """
0226        Expires a single object.  Typically called after a delete.
0227        Doesn't even keep a weakref.  (@@: bad name?)
0228        """
0229        if not self.doCache:
0230            return
0231        self.lock.acquire()
0232        try:
0233            if id in self.cache:
0234                del self.cache[id]
0235            if id in self.expiredCache:
0236                del self.expiredCache[id]
0237        finally:
0238            self.lock.release()
0239
0240    def expireAll(self):
0241        """
0242        Expires all objects, moving them all into the expired/weakref
0243        cache.
0244        """
0245        if not self.doCache:
0246            return
0247        self.lock.acquire()
0248        try:
0249            for key, value in self.cache.items():
0250                self.expiredCache[key] = ref(value)
0251            self.cache = {}
0252        finally:
0253            self.lock.release()
0254
0255    def allIDs(self):
0256        """
0257        Returns the IDs of all objects in the cache.
0258        """
0259        if self.doCache:
0260            all = list(self.cache.keys())
0261        else:
0262            all = []
0263        for id, value in self.expiredCache.items():
0264            if value():
0265                all.append(id)
0266        return all
0267
0268    def getAll(self):
0269        """
0270        Return all the objects in the cache.
0271        """
0272        if self.doCache:
0273            all = list(self.cache.values())
0274        else:
0275            all = []
0276        for value in self.expiredCache.values():
0277            if value():
0278                all.append(value())
0279        return all
0280
0281
0282class CacheSet(object):
0283
0284    """
0285    A CacheSet is used to collect and maintain a series of caches.  In
0286    SQLObject, there is one CacheSet per connection, and one Cache
0287    in the CacheSet for each class, since IDs are not unique across
0288    classes.  It contains methods similar to Cache, but that take
0289    a ``cls`` argument.
0290    """
0291
0292    def __init__(self, *args, **kw):
0293        self.caches = {}
0294        self.args = args
0295        self.kw = kw
0296
0297    def get(self, id, cls):
0298        try:
0299            return self.caches[cls.__name__].get(id)
0300        except KeyError:
0301            self.caches[cls.__name__] = CacheFactory(*self.args, **self.kw)
0302            return self.caches[cls.__name__].get(id)
0303
0304    def put(self, id, cls, obj):
0305        self.caches[cls.__name__].put(id, obj)
0306
0307    def finishPut(self, cls):
0308        self.caches[cls.__name__].finishPut()
0309
0310    def created(self, id, cls, obj):
0311        try:
0312            self.caches[cls.__name__].created(id, obj)
0313        except KeyError:
0314            self.caches[cls.__name__] = CacheFactory(*self.args, **self.kw)
0315            self.caches[cls.__name__].created(id, obj)
0316
0317    def expire(self, id, cls):
0318        try:
0319            self.caches[cls.__name__].expire(id)
0320        except KeyError:
0321            pass
0322
0323    def clear(self, cls=None):
0324        if cls is None:
0325            for cache in self.caches.values():
0326                cache.clear()
0327        elif cls.__name__ in self.caches:
0328            self.caches[cls.__name__].clear()
0329
0330    def tryGet(self, id, cls):
0331        return self.tryGetByName(id, cls.__name__)
0332
0333    def tryGetByName(self, id, clsname):
0334        try:
0335            return self.caches[clsname].tryGet(id)
0336        except KeyError:
0337            return None
0338
0339    def allIDs(self, cls):
0340        try:
0341            self.caches[cls.__name__].allIDs()
0342        except KeyError:
0343            return []
0344
0345    def allSubCaches(self):
0346        return self.caches.values()
0347
0348    def allSubCachesByClassNames(self):
0349        return self.caches
0350
0351    def weakrefAll(self, cls=None):
0352        """
0353        Move all objects in the cls (or if not given, then in all
0354        classes) to the weakref dictionary, where they can be
0355        collected.
0356        """
0357        if cls is None:
0358            for cache in self.caches.values():
0359                cache.expireAll()
0360        elif cls.__name__ in self.caches:
0361            self.caches[cls.__name__].expireAll()
0362
0363    def getAll(self, cls=None):
0364        """
0365        Returns all instances in the cache for the given class or all
0366        classes.
0367        """
0368        if cls is None:
0369            results = []
0370            for cache in self.caches.values():
0371                results.extend(cache.getAll())
0372            return results
0373        elif cls.__name__ in self.caches:
0374            return self.caches[cls.__name__].getAll()
0375        else:
0376            return []
SQLObject-3.1.0/docs/html/sqlobject/include/0000755000175000017500000000000012754657361020176 5ustar phdphd00000000000000SQLObject-3.1.0/docs/html/sqlobject/include/__init__.py.html0000644000175000017500000000471110332042146023230 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/include/__init__.py
0001#
0002
SQLObject-3.1.0/docs/html/sqlobject/dbconnection.py.html0000644000175000017500000117050112503207731022522 0ustar phdphd00000000000000/home/phd/current/projects/SQLObject/SQLObject/sqlobject/dbconnection.py
0001import atexit
0002import inspect
0003import sys
0004import os
0005import threading
0006import types
0007try:
0008    from urlparse import urlparse, parse_qsl
0009    from urllib import unquote, quote, urlencode
0010except ImportError:
0011    from urllib.parse import urlparse, parse_qsl, unquote, quote, urlencode
0012
0013import warnings
0014import weakref
0015
0016from .cache import CacheSet
0017from . import classregistry
0018from . import col
0019from .converters import sqlrepr
0020from . import sqlbuilder
0021from .util.threadinglocal import local as threading_local
0022from .compat import PY2, string_type, unicode_type
0023
0024warnings.filterwarnings("ignore", "DB-API extension cursor.lastrowid used")
0025
0026_connections = {}
0027
0028
0029def _closeConnection(ref):
0030    conn = ref()
0031    if conn is not None:
0032        conn.close()
0033
0034
0035class ConsoleWriter:
0036    def __init__(self, connection, loglevel):
0037        # loglevel: None or empty string for stdout; or 'stderr'
0038        self.loglevel = loglevel or "stdout"
0039        self.dbEncoding = getattr(connection, "dbEncoding", None) or "ascii"
0040
0041    def write(self, text):
0042        logfile = getattr(sys, self.loglevel)
0043        if PY2 and isinstance(text, unicode_type):
0044            try:
0045                text = text.encode(self.dbEncoding)
0046            except UnicodeEncodeError:
0047                text = repr(text)[2:-1]  # Remove u'...' from the repr
0048        logfile.write(text + '\n')
0049
0050
0051class LogWriter:
0052    def __init__(self, connection, logger, loglevel):
0053        self.logger = logger
0054        self.loglevel = loglevel
0055        self.logmethod = getattr(logger, loglevel)
0056
0057    def write(self, text):
0058        self.logmethod(text)
0059
0060
0061def makeDebugWriter(connection, loggerName, loglevel):
0062    if not loggerName:
0063        return ConsoleWriter(connection, loglevel)
0064    import logging
0065    logger = logging.getLogger(loggerName)
0066    return LogWriter(connection, logger, loglevel)
0067
0068
0069class Boolean(object):
0070    """A bool class that also understands some special string keywords
0071
0072    Understands: yes/no, true/false, on/off, 1/0, case ignored.
0073
0074    """
0075    _keywords = {'1': True, 'yes': True, 'true': True, 'on': True,
0076                 '0': False, 'no': False, 'false': False, 'off': False}
0077
0078    def __new__(cls, value):
0079        try:
0080            return Boolean._keywords[value.lower()]
0081        except (AttributeError, KeyError):
0082            return bool(value)
0083
0084
0085class DBConnection:
0086
0087    def __init__(self, name=None, debug=False, debugOutput=False,
0088                 cache=True, style=None, autoCommit=True,
0089                 debugThreading=False, registry=None,
0090                 logger=None, loglevel=None):
0091        self.name = name
0092        self.debug = Boolean(debug)
0093        self.debugOutput = Boolean(debugOutput)
0094        self.debugThreading = Boolean(debugThreading)
0095        self.debugWriter = makeDebugWriter(self, logger, loglevel)
0096        self.doCache = Boolean(cache)
0097        self.cache = CacheSet(cache=self.doCache)
0098        self.style = style
0099        self._connectionNumbers = {}
0100        self._connectionCount = 1
0101        self.autoCommit = Boolean(autoCommit)
0102        self.registry = registry or None
0103        classregistry.registry(self.registry).addCallback(self.soClassAdded)
0104        registerConnectionInstance(self)
0105        atexit.register(_closeConnection, weakref.ref(self))
0106
0107    def oldUri(self):
0108        auth = getattr(self, 'user', '') or ''
0109        if auth:
0110            if self.password:
0111                auth = auth + ':' + self.password
0112            auth = auth + '@'
0113        else:
0114            assert not getattr(self, 'password', None), (
0115                'URIs cannot express passwords without usernames')
0116        uri = '%s://%s' % (self.dbName, auth)
0117        if self.host:
0118            uri += self.host
0119            if self.port:
0120                uri += ':%d' % self.port
0121        uri += '/'
0122        db = self.db
0123        if db.startswith('/'):
0124            db = db[1:]
0125        return uri + db
0126
0127    def uri(self):
0128        auth = getattr(self, 'user', '') or ''
0129        if auth:
0130            auth = quote(auth)
0131            if self.password:
0132                auth = auth + ':' + quote(self.password)
0133            auth = auth + '@'
0134        else:
0135            assert not getattr(self, 'password', None), (
0136                'URIs cannot express passwords without usernames')
0137        uri = '%s://%s' % (self.dbName, auth)
0138        if self.host:
0139            uri += self.host
0140            if self.port:
0141                uri += ':%d' % self.port
0142        uri += '/'
0143        db = self.db
0144        if db.startswith('/'):
0145            db = db[1:]
0146        return uri + quote(db)
0147
0148    @classmethod
0149    def connectionFromOldURI(cls, uri):
0150        return cls._connectionFromParams(*cls._parseOldURI(uri))
0151
0152    @classmethod
0153    def connectionFromURI(cls, uri):
0154        return cls._connectionFromParams(*cls._parseURI(uri))
0155
0156    @staticmethod
0157    def _parseOldURI(uri):
0158        schema, rest = uri.split(':', 1)
0159        assert rest.startswith('/'),               "URIs must start with scheme:/ -- "               "you did not include a / (in %r)" % rest
0162        if rest.startswith('/') and not rest.startswith('//'):
0163            host = None
0164            rest = rest[1:]
0165        elif rest.startswith('///'):
0166            host = None
0167            rest = rest[3:]
0168        else:
0169            rest = rest[2:]
0170            if rest.find('/') == -1:
0171                host = rest
0172                rest = ''
0173            else:
0174                host, rest = rest.split('/', 1)
0175        if host and host.find('@') != -1:
0176            user, host = host.rsplit('@', 1)
0177            if user.find(':') != -1:
0178                user, password = user.split(':', 1)
0179            else:
0180                password = None
0181        else:
0182            user = password = None
0183        if host and host.find(':') != -1:
0184            _host, port = host.split(':')
0185            try:
0186                port = int(port)
0187            except ValueError:
0188                raise ValueError("port must be integer, "
0189                                 "got '%s' instead" % port)
0190            if not (1 <= port <= 65535):
0191                raise ValueError("port must be integer in the range 1-65535, "
0192                                 "got '%d' instead" % port)
0193            host = _host
0194        else:
0195            port = None
0196        path = '/' + rest
0197        if os.name == 'nt':
0198            if (len(rest) > 1) and (rest[1] == '|'):
0199                path = "%s:%s" % (rest[0], rest[2:])
0200        args = {}
0201        if path.find('?') != -1:
0202            path, arglist = path.split('?', 1)
0203            arglist = arglist.split('&')
0204            for single in arglist:
0205                argname, argvalue = single.split('=', 1)
0206                argvalue = unquote(argvalue)
0207                args[argname] = argvalue
0208        return user, password, host, port, path, args
0209
0210    @staticmethod
0211    def _parseURI(uri):
0212        parsed = urlparse(uri)
0213        if sys.version_info[0:2] == (2, 6):
0214            # In python 2.6, urlparse only parses the uri completely
0215            # for certain schemes, so we force the scheme to
0216            # something that will be parsed correctly
0217            scheme = parsed.scheme
0218            parsed = urlparse(uri.replace(scheme, 'http', 1))
0219        host, path = parsed.hostname, parsed.path
0220        user, password, port = None, None, None
0221        if parsed.username:
0222            user = unquote(parsed.username)
0223        if parsed.password:
0224            password = unquote(parsed.password)
0225        if parsed.port:
0226            port = int(parsed.port)
0227
0228        path = unquote(path)
0229        if (os.name == 'nt') and (len(path) > 2):
0230            # Preserve backward compatibility with URIs like /C|/path;
0231            # replace '|' by ':'
0232            if path[2] == '|':
0233                path = "%s:%s" % (path[0:2], path[3:])
0234            # Remove leading slash
0235            if (path[0] == '/') and (path[2] == ':'):
0236                path = path[1:]
0237
0238        query = parsed.query
0239        # hash-tag / fragment is ignored
0240
0241        args = {}
0242        if query:
0243            for name, value in parse_qsl(query):
0244                args[name] = value
0245
0246        return user, password, host, port, path, args
0247
0248    def soClassAdded(self, soClass):
0249        """
0250        This is called for each new class; we use this opportunity
0251        to create an instance method that is bound to the class
0252        and this connection.
0253        """
0254        name = soClass.__name__
0255        assert not hasattr(self, name), (
0256            "Connection %r already has an attribute with the name "
0257            "%r (and you just created the conflicting class %r)"
0258            % (self, name, soClass))
0259        setattr(self, name, ConnWrapper(soClass, self))
0260
0261    def expireAll(self):
0262        """
0263        Expire all instances of objects for this connection.
0264        """
0265        cache_set = self.cache
0266        cache_set.weakrefAll()
0267        for item in cache_set.getAll():
0268            item.expire()
0269
0270
0271class ConnWrapper(object):
0272
0273    """
0274    This represents a SQLObject class that is bound to a specific
0275    connection (instances have a connection instance variable, but
0276    classes are global, so this is binds the connection variable
0277    lazily when a class method is accessed)
0278    """
0279    # @@: methods that take connection arguments should be explicitly
0280    # marked up instead of the implicit use of a connection argument
0281    # and inspect.getargspec()
0282
0283    def __init__(self, soClass, connection):
0284        self._soClass = soClass
0285        self._connection = connection
0286
0287    def __call__(self, *args, **kw):
0288        kw['connection'] = self._connection
0289        return self._soClass(*args, **kw)
0290
0291    def __getattr__(self, attr):
0292        meth = getattr(self._soClass, attr)
0293        if not isinstance(meth, types.MethodType):
0294            # We don't need to wrap non-methods
0295            return meth
0296        try:
0297            takes_conn = meth.takes_connection
0298        except AttributeError:
0299            args, varargs, varkw, defaults = inspect.getargspec(meth)
0300            assert not varkw and not varargs, (
0301                "I cannot tell whether I must wrap this method, "
0302                "because it takes **kw: %r"
0303                % meth)
0304            takes_conn = 'connection' in args
0305            meth.__func__.takes_connection = takes_conn
0306        if not takes_conn:
0307            return meth
0308        return ConnMethodWrapper(meth, self._connection)
0309
0310
0311class ConnMethodWrapper(object):
0312
0313    def __init__(self, method, connection):
0314        self._method = method
0315        self._connection = connection
0316
0317    def __getattr__(self, attr):
0318        return getattr(self._method, attr)
0319
0320    def __call__(self, *args, **kw):
0321        kw['connection'] = self._connection
0322        return self._method(*args, **kw)
0323
0324    def __repr__(self):
0325        return '<Wrapped %r with connection %r>' % (
0326            self._method, self._connection)
0327
0328
0329class DBAPI(DBConnection):
0330
0331    """
0332    Subclass must define a `makeConnection()` method, which
0333    returns a newly-created connection object.
0334
0335    ``queryInsertID`` must also be defined.
0336    """
0337    dbName = None
0338
0339    def __init__(self, **kw):
0340        self._pool = []
0341        self._poolLock = threading.Lock()
0342        DBConnection.__init__(self, **kw)
0343        self._binaryType = type(self.module.Binary(b''))
0344
0345    def _runWithConnection(self, meth, *args):
0346        conn = self.getConnection()
0347        try:
0348            val = meth(conn, *args)
0349        finally:
0350            self.releaseConnection(conn)
0351        return val
0352
0353    def getConnection(self):
0354        self._poolLock.acquire()
0355        try:
0356            if not self._pool:
0357                conn = self.makeConnection()
0358                self._connectionNumbers[id(conn)] = self._connectionCount
0359                self._connectionCount += 1
0360            else:
0361                conn = self._pool.pop()
0362            if self.debug:
0363                s = 'ACQUIRE'
0364                if self._pool is not None:
0365                    s += ' pool=[%s]' % ', '.join(
0366                        [str(self._connectionNumbers[id(v)])
0367                            for v in self._pool])
0368                self.printDebug(conn, s, 'Pool')
0369            return conn
0370        finally:
0371            self._poolLock.release()
0372
0373    def releaseConnection(self, conn, explicit=False):
0374        if self.debug:
0375            if explicit:
0376                s = 'RELEASE (explicit)'
0377            else:
0378                s = 'RELEASE (implicit, autocommit=%s)' % self.autoCommit
0379            if self._pool is None:
0380                s += ' no pooling'
0381            else:
0382                s += ' pool=[%s]' % ', '.join(
0383                    [str(self._connectionNumbers[id(v)]) for v in self._pool])
0384            self.printDebug(conn, s, 'Pool')
0385        if self.supportTransactions and not explicit:
0386            if self.autoCommit == 'exception':
0387                if self.debug:
0388                    self.printDebug(conn, 'auto/exception', 'ROLLBACK')
0389                conn.rollback()
0390                raise Exception('Object used outside of a transaction; '
0391                                'implicit COMMIT or ROLLBACK not allowed')
0392            elif self.autoCommit:
0393                if self.debug:
0394                    self.printDebug(conn, 'auto', 'COMMIT')
0395                if not getattr(conn, 'autocommit', False):
0396                    conn.commit()
0397            else:
0398                if self.debug:
0399                    self.printDebug(conn, 'auto', 'ROLLBACK')
0400                conn.rollback()
0401        if self._pool is not None:
0402            if conn not in self._pool:
0403                # @@: We can get duplicate releasing of connections with
0404                # the __del__ in Iteration (unfortunately, not sure why
0405                # it happens)
0406                self._pool.insert(0, conn)
0407        else:
0408            conn.close()
0409
0410    def printDebug(self, conn, s, name, type='query'):
0411        if name == 'Pool' and self.debug != 'Pool':
0412            return
0413        if type == 'query':
0414            sep = ': '
0415        else:
0416            sep = '->'
0417            s = repr(s)
0418        n = self._connectionNumbers[id(conn)]
0419        spaces = ' ' * (8 - len(name))
0420        if self.debugThreading:
0421            threadName = threading.currentThread().getName()
0422            threadName = (':' + threadName + ' ' * (8 - len(threadName)))
0423        else:
0424            threadName = ''
0425        msg = '%(n)2i%(threadName)s/%(name)s%(spaces)s%(sep)s %(s)s' % locals()
0426        self.debugWriter.write(msg)
0427
0428    def _executeRetry(self, conn, cursor, query):
0429        if self.debug:
0430            self.printDebug(conn, query, 'QueryR')
0431        return cursor.execute(query)
0432
0433    def _query(self, conn, s):
0434        if self.debug:
0435            self.printDebug(conn, s, 'Query')
0436        self._executeRetry(conn, conn.cursor(), s)
0437
0438    def query(self, s):
0439        return self._runWithConnection(self._query, s)
0440
0441    def _queryAll(self, conn, s):
0442        if self.debug:
0443            self.printDebug(conn, s, 'QueryAll')
0444        c = conn.cursor()
0445        self._executeRetry(conn, c, s)
0446        value = c.fetchall()
0447        if self.debugOutput:
0448            self.printDebug(conn, value, 'QueryAll', 'result')
0449        return value
0450
0451    def queryAll(self, s):
0452        return self._runWithConnection(self._queryAll, s)
0453
0454    def _queryAllDescription(self, conn, s):
0455        """
0456        Like queryAll, but returns (description, rows), where the
0457        description is cursor.description (which gives row types)
0458        """
0459        if self.debug:
0460            self.printDebug(conn, s, 'QueryAllDesc')
0461        c = conn.cursor()
0462        self._executeRetry(conn, c, s)
0463        value = c.fetchall()
0464        if self.debugOutput:
0465            self.printDebug(conn, value, 'QueryAll', 'result')
0466        return c.description, value
0467
0468    def queryAllDescription(self, s):
0469        return self._runWithConnection(self._queryAllDescription, s)
0470
0471    def _queryOne(self, conn, s):
0472        if self.debug:
0473            self.printDebug(conn, s, 'QueryOne')
0474        c = conn.cursor()
0475        self._executeRetry(conn, c, s)
0476        value = c.fetchone()
0477        if self.debugOutput:
0478            self.printDebug(conn, value, 'QueryOne', 'result')
0479        return value
0480
0481    def queryOne(self, s):
0482        return self._runWithConnection(self._queryOne, s)
0483
0484    def _insertSQL(self, table, names, values):
0485        return ("INSERT INTO %s (%s) VALUES (%s)" %
0486                (table, ', '.join(names),
0487                 ', '.join([self.sqlrepr(v) for v in values])))
0488
0489    def transaction(self):
0490        return Transaction(self)
0491
0492    def queryInsertID(self, soInstance, id, names, values):
0493        return self._runWithConnection(self._queryInsertID, soInstance, id,
0494                                       names, values)
0495
0496    def iterSelect(self, select):
0497        return select.IterationClass(self, self.getConnection(),
0498                                     select, keepConnection=False)
0499
0500    def accumulateSelect(self, select, *expressions):
0501        """ Apply an accumulate function(s) (SUM, COUNT, MIN, AVG, MAX, etc...)
0502            to the select object.
0503        """
0504        q = select.queryForSelect().newItems(expressions).              unlimited().orderBy(None)
0506        q = self.sqlrepr(q)
0507        val = self.queryOne(q)
0508        if len(expressions) == 1:
0509            val = val[0]
0510        return val
0511
0512    def queryForSelect(self, select):
0513        return self.sqlrepr(select.queryForSelect())
0514
0515    def _SO_createJoinTable(self, join):
0516        self.query(self._SO_createJoinTableSQL(join))
0517
0518    def _SO_createJoinTableSQL(self, join):
0519        return ('CREATE TABLE %s (\n%s %s,\n%s %s\n)' %
0520                (join.intermediateTable,
0521                 join.joinColumn,
0522                 self.joinSQLType(join),
0523                 join.otherColumn,
0524                 self.joinSQLType(join)))
0525
0526    def _SO_dropJoinTable(self, join):
0527        self.query("DROP TABLE %s" % join.intermediateTable)
0528
0529    def _SO_createIndex(self, soClass, index):
0530        self.query(self.createIndexSQL(soClass, index))
0531
0532    def createIndexSQL(self, soClass, index):
0533        assert 0, 'Implement in subclasses'
0534
0535    def createTable(self, soClass):
0536        createSql, constraints = self.createTableSQL(soClass)
0537        self.query(createSql)
0538
0539        return constraints
0540
0541    def createReferenceConstraints(self, soClass):
0542        refConstraints = [self.createReferenceConstraint(soClass, column)
0543                          for column in soClass.sqlmeta.columnList
0544                          if isinstance(column, col.SOForeignKey)]
0545        refConstraintDefs = [constraint for constraint in refConstraints
0546                             if constraint]
0547        return refConstraintDefs
0548
0549    def createSQL(self, soClass):
0550        tableCreateSQLs = getattr(soClass.sqlmeta, 'createSQL', None)
0551        if tableCreateSQLs:
0552            assert isinstance(tableCreateSQLs, (str, list, dict, tuple)), (
0553                '%s.sqlmeta.createSQL must be a str, list, dict or tuple.' %
0554                (soClass.__name__))
0555            if isinstance(tableCreateSQLs, dict):
0556                tableCreateSQLs = tableCreateSQLs.get(
0557                    soClass._connection.dbName, [])
0558            if isinstance(tableCreateSQLs, str):
0559                tableCreateSQLs = [tableCreateSQLs]
0560            if isinstance(tableCreateSQLs, tuple):
0561                tableCreateSQLs = list(tableCreateSQLs)
0562            assert isinstance(tableCreateSQLs, list), (
0563                'Unable to create a list from %s.sqlmeta.createSQL' %
0564                (soClass.__name__))
0565        return tableCreateSQLs or []
0566
0567    def createTableSQL(self, soClass):
0568        constraints = self.createReferenceConstraints(soClass)
0569        extraSQL = self.createSQL(soClass)
0570        createSql = ('CREATE TABLE %s (\n%s\n)' %
0571                     (soClass.sqlmeta.table, self.createColumns(soClass)))
0572        return createSql, constraints + extraSQL
0573
0574    def createColumns(self, soClass):
0575        columnDefs = [self.createIDColumn(soClass)]               + [self.createColumn(soClass, col)
0577               for col in soClass.sqlmeta.columnList]
0578        return ",\n".join(["    %s" % c for c in columnDefs])
0579
0580    def createReferenceConstraint(self, soClass, col):
0581        assert 0, "Implement in subclasses"
0582
0583    def createColumn(self, soClass, col):
0584        assert 0, "Implement in subclasses"
0585
0586    def dropTable(self, tableName, cascade=False):
0587        self.query("DROP TABLE %s" % tableName)
0588
0589    def clearTable(self, tableName):
0590        # 3-03 @@: Should this have a WHERE 1 = 1 or similar
0591        # clause?  In some configurations without the WHERE clause
0592        # the query won't go through, but maybe we shouldn't override
0593        # that.
0594        self.query("DELETE FROM %s" % tableName)
0595
0596    def createBinary(self, value):
0597        """
0598        Create a binary object wrapper for the given database.
0599        """
0600        # Default is Binary() function from the connection driver.
0601        return self.module.Binary(value)
0602
0603    # The _SO_* series of methods are sorts of "friend" methods
0604    # with SQLObject.  They grab values from the SQLObject instances
0605    # or classes freely, but keep the SQLObject class from accessing
0606    # the database directly.  This way no SQL is actually created
0607    # in the SQLObject class.
0608
0609    def _SO_update(self, so, values):
0610        self.query("UPDATE %s SET %s WHERE %s = (%s)" %
0611                   (so.sqlmeta.table,
0612                    ", ".join(["%s = (%s)" % (dbName, self.sqlrepr(value))
0613                               for dbName, value in values]),
0614                    so.sqlmeta.idName,
0615                    self.sqlrepr(so.id)))
0616
0617    def _SO_selectOne(self, so, columnNames):
0618        return self._SO_selectOneAlt(so, columnNames, so.q.id == so.id)
0619
0620    def _SO_selectOneAlt(self, so, columnNames, condition):
0621        if columnNames:
0622            columns = [isinstance(x, string_type) and
0623                       sqlbuilder.SQLConstant(x) or
0624                       x for x in columnNames]
0625        else:
0626            columns = None
0627        return self.queryOne(self.sqlrepr(sqlbuilder.Select(
0628            columns, staticTables=[so.sqlmeta.table], clause=condition)))
0629
0630    def _SO_delete(self, so):
0631        self.query("DELETE FROM %s WHERE %s = (%s)" %
0632                   (so.sqlmeta.table,
0633                    so.sqlmeta.idName,
0634                    self.sqlrepr(so.id)))
0635
0636    def _SO_selectJoin(self, soClass, column, value):
0637        return self.queryAll("SELECT %s FROM %s WHERE %s = (%s)" %
0638                             (soClass.sqlmeta.idName,
0639                              soClass.sqlmeta.table,
0640                              column,
0641                              self.sqlrepr(value)))
0642
0643    def _SO_intermediateJoin(self, table, getColumn, joinColumn, value):
0644        return self.queryAll("SELECT %s FROM %s WHERE %s = (%s)" %
0645                             (getColumn,
0646                              table,
0647                              joinColumn,
0648                              self.sqlrepr(value)))
0649
0650    def _SO_intermediateDelete(self, table, firstColumn, firstValue,
0651                               secondColumn, secondValue):
0652        self.query("DELETE FROM %s WHERE %s = (%s) AND %s = (%s)" %
0653                   (table,
0654                    firstColumn,
0655                    self.sqlrepr(firstValue),
0656                    secondColumn,
0657                    self.sqlrepr(secondValue)))
0658
0659    def _SO_intermediateInsert(self, table, firstColumn, firstValue,
0660                               secondColumn, secondValue):
0661        self.query("INSERT INTO %s (%s, %s) VALUES (%s, %s)" %
0662                   (table,
0663                    firstColumn,
0664                    secondColumn,
0665                    self.sqlrepr(firstValue),
0666                    self.sqlrepr(secondValue)))
0667
0668    def _SO_columnClause(self, soClass, kw):
0669        from . import main
0670        ops = {None: "IS"}
0671        data = []
0672        if 'id' in kw:
0673            data.append((soClass.sqlmeta.idName, kw.pop('id')))
0674        for soColumn in soClass.sqlmeta.columnList:
0675            key = soColumn.name
0676            if key in kw:
0677                val = kw.pop(key)
0678                if soColumn.from_python:
0679                    val = soColumn.from_python(
0680                        val,
0681                        sqlbuilder.SQLObjectState(soClass, connection=self))
0682                data.append((soColumn.dbName, val))
0683            elif soColumn.foreignName in kw:
0684                obj = kw.pop(soColumn.foreignName)
0685                if isinstance(obj, main.SQLObject):
0686                    data.append((soColumn.dbName, obj.id))
0687                else:
0688                    data.append((soColumn.dbName, obj))
0689        if kw:
0690            # pick the first key from kw to use to raise the error,
0691            raise TypeError("got an unexpected keyword argument(s): "
0692                            "%r" % kw.keys())
0693
0694        if not data:
0695            return None
0696        return ' AND '.join(
0697            ['%s %s %s' %
0698             (dbName, ops.get(value, "="), self.sqlrepr(value))
0699             for dbName, value
0700             in data])
0701
0702    def sqlrepr(self, v):
0703        return sqlrepr(v, self.dbName)
0704
0705    def __del__(self):
0706        self.close()
0707
0708    def close(self):
0709        if not hasattr(self, '_pool'):
0710            # Probably there was an exception while creating this
0711            # instance, so it is incomplete.
0712            return
0713        if not self._pool:
0714            return
0715        self._poolLock.acquire()
0716        try:
0717            if not self._pool:  # _pool could be filled in a different thread
0718                return
0719            conns = self._pool[:]
0720            self._pool[:] = []
0721            for conn in conns:
0722                try:
0723                    conn.close()
0724                except self.module.Error:
0725                    pass
0726            del conn
0727            del conns
0728        finally:
0729            self._poolLock.release()
0730
0731    def createEmptyDatabase(self):
0732        """
0733        Create an empty database.
0734        """
0735        raise NotImplementedError
0736
0737
0738class Iteration(object):
0739
0740    def __init__(self, dbconn, rawconn, select, keepConnection=False):
0741        self.dbconn = dbconn
0742        self.rawconn = rawconn
0743        self.select = select
0744        self.keepConnection = keepConnection
0745        self.cursor = rawconn.cursor()
0746        self.query = self.dbconn.queryForSelect(select)
0747        if dbconn.debug:
0748            dbconn.printDebug(rawconn, self.query, 'Select')
0749        self.dbconn._executeRetry(self.rawconn, self.cursor, self.query)
0750
0751    def __iter__(self):
0752        return self
0753
0754    def __next__(self):
0755        return self.next()
0756
0757    def next(self):
0758        result = self.cursor.fetchone()
0759        if result is None:
0760            self._cleanup()
0761            raise StopIteration
0762        if result[0] is None:
0763            return None
0764        if self.select.ops.get('lazyColumns', 0):
0765            obj = self.select.sourceClass.get(result[0],
0766                                              connection=self.dbconn)
0767            return obj
0768        else:
0769            obj = self.select.sourceClass.get(result[0],
0770                                              selectResults=result[1:],
0771                                              connection=self.dbconn)
0772            return obj
0773
0774    def _cleanup(self):
0775        if getattr(self, 'query', None) is None:
0776            # already cleaned up
0777            return
0778        self.query = None
0779        if not self.keepConnection:
0780            self.dbconn.releaseConnection(self.rawconn)
0781        self.dbconn = self.rawconn = self.select = self.cursor = None
0782
0783    def __del__(self):
0784        self._cleanup()
0785
0786
0787class Transaction(object):
0788
0789    def __init__(self, dbConnection):
0790        # this is to skip __del__ in case of an exception in this __init__
0791        self._obsolete = True
0792        self._dbConnection = dbConnection
0793        self._connection = dbConnection.getConnection()
0794        self._dbConnection._setAutoCommit(self._connection, 0)
0795        self.cache = CacheSet(cache=dbConnection.doCache)
0796        self._deletedCache = {}
0797        self._obsolete = False
0798
0799    def assertActive(self):
0800        assert not self._obsolete,               "This transaction has already gone through ROLLBACK; "               "begin another transaction"
0803
0804    def query(self, s):
0805        self.assertActive()
0806        return self._dbConnection._query(self._connection, s)
0807
0808    def queryAll(self, s):
0809        self.assertActive()
0810        return self._dbConnection._queryAll(self._connection, s)
0811
0812    def queryOne(self, s):
0813        self.assertActive()
0814        return self._dbConnection._queryOne(self._connection, s)
0815
0816    def queryInsertID(self, soInstance, id, names, values):
0817        self.assertActive()
0818        return self._dbConnection._queryInsertID(
0819            self._connection, soInstance, id, names, values)
0820
0821    def iterSelect(self, select):
0822        self.assertActive()
0823        # We can't keep the cursor open with results in a transaction,
0824        # because we might want to use the connection while we're
0825        # still iterating through the results.
0826        # @@: But would it be okay for psycopg, with threadsafety
0827        # level 2?
0828        return iter(list(select.IterationClass(self, self._connection,
0829                                               select, keepConnection=True)))
0830
0831    def _SO_delete(self, inst):
0832        cls = inst.__class__.__name__
0833        if cls not in self._deletedCache:
0834            self._deletedCache[cls] = []
0835        self._deletedCache[cls].append(inst.id)
0836        if PY2:
0837            meth = types.MethodType(self._dbConnection._SO_delete.__func__,
0838                                    self, self.__class__)
0839        else:
0840            meth = types.MethodType(self._dbConnection._SO_delete.__func__,
0841                                    self)
0842        return meth(inst)
0843
0844    def commit(self, close=False):
0845        if self._obsolete:
0846            # @@: is it okay to get extraneous commits?
0847            return
0848        if self._dbConnection.debug:
0849            self._dbConnection.printDebug(self._connection, '', 'COMMIT')
0850        self._connection.commit()
0851        subCaches = [(sub[0], sub[1].allIDs())
0852                     for sub in self.cache.allSubCachesByClassNames().items()]
0853        subCaches.extend([(x[0], x[1]) for x in self._deletedCache.items()])
0854        for cls, ids in subCaches:
0855            for id in list(ids):
0856                inst = self._dbConnection.cache.tryGetByName(id, cls)
0857                if inst is not None:
0858                    inst.expire()
0859        if close:
0860            self._makeObsolete()
0861
0862    def rollback(self):
0863        if self._obsolete:
0864            # @@: is it okay to get extraneous rollbacks?
0865            return
0866        if self._dbConnection.debug:
0867            self._dbConnection.printDebug(self._connection, '', 'ROLLBACK')
0868        subCaches = [(sub, sub.allIDs()) for sub in self.cache.allSubCaches()]
0869        self._connection.rollback()
0870
0871        for subCache, ids in subCaches:
0872            for id in list(ids):
0873                inst = subCache.tryGet(id)
0874                if inst is not None:
0875                    inst.expire()
0876        self._makeObsolete()
0877
0878    def __getattr__(self, attr):
0879        """
0880        If nothing else works, let the parent connection handle it.
0881        Except with this transaction as 'self'.  Poor man's
0882        acquisition?  Bad programming?  Okay, maybe.
0883        """
0884        self.assertActive()
0885        attr = getattr(self._dbConnection, attr)
0886        try:
0887            func = attr.__func__
0888        except AttributeError:
0889            if isinstance(attr, ConnWrapper):
0890                return ConnWrapper(attr._soClass, self)
0891            else:
0892                return attr
0893        else:
0894            if PY2:
0895                meth = types.MethodType(func, self, self.__class__)
0896            else:
0897                meth = types.MethodType(func, self)
0898            return meth
0899
0900    def _makeObsolete(self):
0901        self._obsolete = True
0902        if self._dbConnection.autoCommit:
0903            self._dbConnection._setAutoCommit(self._connection, 1)
0904        self._dbConnection.releaseConnection(self._connection,
0905                                             explicit=True)
0906        self._connection = None
0907        self._deletedCache = {}
0908
0909    def begin(self):
0910        # @@: Should we do this, or should begin() be a no-op when we're
0911        # not already obsolete?
0912        assert self._obsolete,               "You cannot begin a new transaction session "               "without rolling back this one"
0915        self._obsolete = False
0916        self._connection = self._dbConnection.getConnection()
0917        self._dbConnection._setAutoCommit(self._connection, 0)
0918
0919    def __del__(self):
0920        if self._obsolete:
0921            return
0922        self.rollback()
0923
0924    def close(self):
0925        raise TypeError('You cannot just close transaction - '
0926                        'you should either call rollback(), commit() '
0927                        'or commit(close=True) '
0928                        'to close the underlying connection.')
0929
0930
0931class ConnectionHub(object):
0932
0933    """
0934    This object serves as a hub for connections, so that you can pass
0935    in a ConnectionHub to a SQLObject subclass as though it was a
0936    connection, but actually bind a real database connection later.
0937    You can also bind connections on a per-thread basis.
0938
0939    You must hang onto the original ConnectionHub instance, as you
0940    cannot retrieve it again from the class or instance.
0941
0942    To use the hub, do something like::
0943
0944        hub = ConnectionHub()
0945        class MyClass(SQLObject):
0946            _connection = hub
0947
0948        hub.threadConnection = connectionFromURI('...')
0949
0950    """
0951
0952    def __init__(self):
0953        self.threadingLocal = threading_local()
0954
0955    def __get__(self, obj, type=None):
0956        # I'm a little surprised we have to do this, but apparently
0957        # the object's private dictionary of attributes doesn't
0958        # override this descriptor.
0959        if (obj is not None) and '_connection' in obj.__dict__:
0960            return obj.__dict__['_connection']
0961        return self.getConnection()
0962
0963    def __set__(self, obj, value):
0964        obj.__dict__['_connection'] = value
0965
0966    def getConnection(self):
0967        try:
0968            return self.threadingLocal.connection
0969        except AttributeError:
0970            try:
0971                return self.processConnection
0972            except AttributeError:
0973                raise AttributeError(
0974                    "No connection has been defined for this thread "
0975                    "or process")
0976
0977    def doInTransaction(self, func, *args, **kw):
0978        """
0979        This routine can be used to run a function in a transaction,
0980        rolling the transaction back if any exception is raised from
0981        that function, and committing otherwise.
0982
0983        Use like::
0984
0985            sqlhub.doInTransaction(process_request, os.environ)
0986
0987        This will run ``process_request(os.environ)``.  The return
0988        value will be preserved.
0989        """
0990        # @@: In Python 2.5, something usable with with: should also
0991        # be added.
0992        try:
0993            old_conn = self.threadingLocal.connection
0994            old_conn_is_threading = True
0995        except AttributeError:
0996            old_conn = self.processConnection
0997            old_conn_is_threading = False
0998        conn = old_conn.transaction()
0999        if old_conn_is_threading:
1000            self.threadConnection = conn
1001        else:
1002            self.processConnection = conn
1003        try:
1004            try:
1005                value = func(*args, **kw)
1006            except:
1007                conn.rollback()
1008                raise
1009            else:
1010                conn.commit(close=True)
1011                return value
1012        finally:
1013            if old_conn_is_threading:
1014                self.threadConnection = old_conn
1015            else:
1016                self.processConnection = old_conn
1017
1018    def _set_threadConnection(self, value):
1019        self.threadingLocal.connection = value
1020
1021    def _get_threadConnection(self):
1022        return self.threadingLocal.connection
1023
1024    def _del_threadConnection(self):
1025        del self.threadingLocal.connection
1026
1027    threadConnection = property(_get_threadConnection,
1028                                _set_threadConnection,
1029                                _del_threadConnection)
1030
1031
1032class ConnectionURIOpener(object):
1033
1034    def __init__(self):
1035        self.schemeBuilders = {}
1036        self.instanceNames = {}
1037        self.cachedURIs = {}
1038
1039    def registerConnection(self, schemes, builder):
1040        for uriScheme in schemes:
1041            assert uriScheme not in self.schemeBuilders                   or self.schemeBuilders[uriScheme] is builder,                   "A driver has already been registered "                   "for the URI scheme %s" % uriScheme
1045            self.schemeBuilders[uriScheme] = builder
1046
1047    def registerConnectionInstance(self, inst):
1048        if inst.name:
1049            assert (inst.name not in self.instanceNames or
1050                    self.instanceNames[inst.name] is cls  # noqa
1051                ), ("A instance has already been registered "
1052                "with the name %s" % inst.name)
1053            assert inst.name.find(':') == -1,                   "You cannot include ':' "                   "in your class names (%r)" % cls.name  # noqa
1056            self.instanceNames[inst.name] = inst
1057
1058    def connectionForURI(self, uri, oldUri=False, **args):
1059        if args:
1060            if '?' not in uri:
1061                uri += '?' + urlencode(args)
1062            else:
1063                uri += '&' + urlencode(args)
1064        if uri in self.cachedURIs:
1065            return self.cachedURIs[uri]
1066        if uri.find(':') != -1:
1067            scheme, rest = uri.split(':', 1)
1068            connCls = self.dbConnectionForScheme(scheme)
1069            if oldUri:
1070                conn = connCls.connectionFromOldURI(uri)
1071            else:
1072                conn = connCls.connectionFromURI(uri)
1073        else:
1074            # We just have a name, not a URI
1075            assert uri in self.instanceNames,                   "No SQLObject driver exists under the name %s" % uri
1077            conn = self.instanceNames[uri]
1078        # @@: Do we care if we clobber another connection?
1079        self.cachedURIs[uri] = conn
1080        return conn
1081
1082    def dbConnectionForScheme(self, scheme):
1083        assert scheme in self.schemeBuilders, (
1084            "No SQLObject driver exists for %s (only %s)" % (
1085                scheme,
1086                ', '.join(self.schemeBuilders.keys())))
1087        return self.schemeBuilders[scheme]()
1088
1089TheURIOpener = ConnectionURIOpener()
1090
1091registerConnection = TheURIOpener.registerConnection
1092registerConnectionInstance = TheURIOpener.registerConnectionInstance
1093connectionForURI = TheURIOpener.connectionForURI
1094dbConnectionForScheme = TheURIOpener.dbConnectionForScheme
1095
1096# Register DB URI schemas -- do import for side effects
1097# noqa is a directive for flake8 to ignore seemingly unused imports
1098from . import firebird  # noqa
1099from . import maxdb  # noqa
1100from . import mssql  # noqa
1101from . import mysql  # noqa
1102from . import postgres  # noqa
1103from . import rdbhost  # noqa
1104from . import sqlite  # noqa
1105from . import sybase  # noqa
SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.ConsoleWriter.html0000644000175000017500000000355612754657340026014 0ustar phdphd00000000000000

ConsoleWriter

The ConsoleWriter class is accessible via the sqlobject.dbconnection module.

Methods

f __init__(self, connection, loglevel) ...

f write(self, text) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlite.sqliteconnection.ErrorMessage.html0000644000175000017500000002536312754657337030035 0ustar phdphd00000000000000

ErrorMessage

The ErrorMessage class is accessible via the sqlobject.sqlite.sqliteconnection module.

Methods

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __rmod__(...) ...

x.__rmod__(y) <==> y%x

f __rmul__(...) ...

x.__rmul__(n) <==> n*x

f __sizeof__(...) ...

S.__sizeof__() -> size of S in memory, in bytes

f __getnewargs__(...) ...

f __lt__(...) ...

x.__lt__(y) <==> x<y

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

f __contains__(...) ...

x.__contains__(y) <==> y in x

f __format__(...) ...

S.__format__(format_spec) -> string

Return a formatted version of S as described by format_spec.

f __len__(...) ...

x.__len__() <==> len(x)

f __ne__(...) ...

x.__ne__(y) <==> x!=y

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __add__(...) ...

x.__add__(y) <==> x+y

f __gt__(...) ...

x.__gt__(y) <==> x>y

f __eq__(...) ...

x.__eq__(y) <==> x==y

f __mod__(...) ...

x.__mod__(y) <==> x%y

f __le__(...) ...

x.__le__(y) <==> x<=y

f __mul__(...) ...

x.__mul__(n) <==> x*n

f __ge__(...) ...

x.__ge__(y) <==> x>=y

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLOp.html0000644000175000017500000004074712754657331023657 0ustar phdphd00000000000000

SQLOp

The SQLOp class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, op, expr1, expr2) ...

f __sqlrepr__(self, db) ...

f components(self) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.dberrors.html0000644000175000017500000002044312754657322022545 0ustar phdphd00000000000000

dberrors

dberrors: database exception classes for SQLObject.

The dberrors module is accessible via the sqlobject module.

These classes are dictated by the DB API v2.0, see: https://wiki.python.org/moin/DatabaseProgramming

Attributes

a PY2

True

a __package__

'sqlobject'

Classes

C Error(...) ...

This class contains 10 members.

C Warning(...) ...

This class contains 10 members.

C InterfaceError(...) ...

This class contains 10 members.

C DatabaseError(...) ...

This class contains 10 members.

C InternalError(...) ...

This class contains 10 members.

C OperationalError(...) ...

This class contains 10 members.

C ProgrammingError(...) ...

This class contains 10 members.

C IntegrityError(...) ...

This class contains 10 members.

C DataError(...) ...

This class contains 10 members.

C NotSupportedError(...) ...

This class contains 10 members.

C DuplicateEntryError(...) ...

This class contains 10 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.INSubquery.html0000644000175000017500000004122712754657326024765 0ustar phdphd00000000000000

INSubquery

The INSubquery class is accessible via the sqlobject.sqlbuilder module.

Attributes

a op

'IN'

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, item, subquery) ...

f components(self) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SmallIntCol.html0000644000175000017500000000753312754657350023506 0ustar phdphd00000000000000

SmallIntCol

The SmallIntCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandRunner.html0000644000175000017500000001062112754657313026336 0ustar phdphd00000000000000

CommandRunner

The CommandRunner class is accessible via the sqlobject.manager.command module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self) ...

f run(self, argv) ...

f register(self, command) ...

f invalid(self, msg, code=2) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandUpgrade.html0000644000175000017500000005004512754657315026462 0ustar phdphd00000000000000

CommandUpgrade

The CommandUpgrade class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

'This command runs scripts (that you write by hand) to upgrade a database.  The database\'s current version is in the sqlobject_version table (use record --force-db-version if a database does not have a sqlobject_version table), and upgrade scripts are in the version directory you are upgrading FROM, named upgrade_DBNAME_VERSION.sql, like "upgrade_mysql_2004-12-01b.sql".'

a parser

<optparse.OptionParser instance at 0xb64e7f2c>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'upgrade'

a summary

'Update the database to a new version (as created by record)'

a min_args_error

'You must provide at least %(min_args)s arguments'

a version_regex

<_sre.SRE_Pattern object at 0xb64e9120>

a upgrade_regex

<_sre.SRE_Pattern object at 0xb6630960>

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f update_db(self, version, conn) ...

f strip_comments(self, sql) ...

f base_dir(self) ...

f find_output_dir(self) ...

f find_last_version(self) ...

f command_force_db_version(self) ...

f command(self) ...

f current_version(self) ...

f make_plan(self, current, dest) ...

f best_upgrade(self, current, dest, target_dbname) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.main-index.html0000644000175000017500000004202512754657334022757 0ustar phdphd00000000000000 Index of sqlobject.main module

Index of the main module

SQLObject-3.1.0/docs/html/class-sqlobject.col.SODecimalStringCol.html0000644000175000017500000002370512754657346024756 0ustar phdphd00000000000000

SODecimalStringCol

The SODecimalStringCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f autoConstraints(self) ...

f __init__(self, **kw) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.main.sqlmeta.html0000644000175000017500000003617512754657335023151 0ustar phdphd00000000000000

sqlmeta

This object is the object we use to keep track of all sorts of information. Subclasses are made for each SQLObject subclass (dynamically if necessary), and instances are created to go alongside every SQLObject instance.

The sqlmeta class is accessible via the sqlobject.main module.

Attributes

a idName

None

a childName

None

a columnDefinitions

{}

a defaultOrder

None

a style

None

a fromDatabase

False

a table

None

a idSequence

None

a indexes

[]

a dbEncoding

None

a childClasses

{}

a columnList

[]

a columns

{}

a indexDefinitions

[]

a registry

None

a joins

[]

a cacheValues

True

a expired

False

a parentClass

None

a lazyUpdate

False

a dirty

False

a joinDefinitions

[]

Methods

f __format__(...) ...

default object formatter

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __classinit__(cls, new_attrs) ...

f __init__(self, instance) ...

f send(cls, signal, *args, **kw) ...

f setClass(cls, soClass) ...

f addColumn(cls, columnDef, changeSchema=False, connection=None) ...

f addColumnsFromDatabase(sqlmeta, connection=None) ...

f delColumn(cls, column, changeSchema=False, connection=None) ...

f addJoin(cls, joinDef) ...

f delJoin(sqlmeta, joinDef) ...

f addIndex(cls, indexDef) ...

f getColumns(sqlmeta) ...

f asDict(self) ...

Return the object as a dictionary of columns to values.

f expireAll(sqlmeta, connection=None) ...

Expire all instances of this class.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLObjectState.html0000644000175000017500000000622012754657327025501 0ustar phdphd00000000000000

SQLObjectState

The SQLObjectState class is accessible via the sqlobject.sqlbuilder module.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, soObject, connection=None) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.styles.html0000644000175000017500000001101612754657335022246 0ustar phdphd00000000000000

styles

The styles module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Classes

C Style(...) ...

The base Style class, and also the simplest implementation. No translation occurs -- column names and attribute names match, as do class names and table names (when using auto class or schema generation).

This class contains 13 members.

C MixedCaseUnderscoreStyle(...) ...

This is the default style. Python attributes use mixedCase, while database columns use underscore_separated.

This class contains 14 members.

C DefaultStyle(...) ...

This is the default style. Python attributes use mixedCase, while database columns use underscore_separated.

This class contains 14 members.

C MixedCaseStyle(...) ...

This style leaves columns as mixed-case, and uses long ID names (like ProductID instead of simply id).

This class contains 13 members.

See the source for more information.

SQLObject-3.1.0/docs/html/index.html0000644000175000017500000001144512754657233016565 0ustar phdphd00000000000000 SQLObject

SQLObject

SQLObject is a popular Object Relational Manager for providing an object interface to your database, with tables as classes, rows as instances, and columns as attributes.

SQLObject includes a Python-object-based query language that makes SQL more abstract, and provides substantial database independence for applications.

Example

This is just a snippet that creates a simple class that wraps a table:

>>> from sqlobject import *
>>>
>>> sqlhub.processConnection = connectionForURI('sqlite:/:memory:')
>>>
>>> class Person(SQLObject):
...     fname = StringCol()
...     mi = StringCol(length=1, default=None)
...     lname = StringCol()
...
>>> Person.createTable()

SQLObject supports most database schemas that you already have, and can also issue the CREATE statement for you (seen in Person.createTable()).

Here's how you'd use the object:

>>> p = Person(fname="John", lname="Doe")
>>> p
<Person 1 fname='John' mi=None lname='Doe'>
>>> p.fname
'John'
>>> p.mi = 'Q'
>>> p2 = Person.get(1)
>>> p2
<Person 1 fname='John' mi='Q' lname='Doe'>
>>> p is p2
True
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.include.hashcol.HashCol.html0000644000175000017500000000735712754657317025143 0ustar phdphd00000000000000

HashCol

End-user HashCol class. May be instantiated with 'hashMethod', a function which returns the string hash of any other string (i.e. basestring).

The HashCol class is accessible via the sqlobject.include.hashcol module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mysql.mysqlconnection.html0000644000175000017500000000703012754657315025313 0ustar phdphd00000000000000

mysqlconnection

The mysqlconnection module is accessible via the sqlobject.mysql module.

Attributes

a mysql_Bin

None

a PY2

True

a __package__

'sqlobject.mysql'

Classes

C ErrorMessage(...) ...

This class contains 20 members.

C MySQLConnection(...) ...

This class contains 22 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.main.SQLObjectIntegrityError.html0000644000175000017500000001341612754657334026172 0ustar phdphd00000000000000

SQLObjectIntegrityError

The SQLObjectIntegrityError class is accessible via the sqlobject.main module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.manager.html0000644000175000017500000000371112754657306022336 0ustar phdphd00000000000000

manager

The manager module is accessible via the sqlobject module.

Attributes

a __package__

None

Modules

The sqlobject.manager module exposes 1 submodules:

command

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.manager.command.html0000644000175000017500000003074712754657312023761 0ustar phdphd00000000000000

command

The command module is accessible via the sqlobject.manager module.

Attributes

a PY2

True

a the_runner

<sqlobject.manager.command.CommandRunner object at 0xb64d6e0c>

a __package__

'sqlobject.manager'

a print_function

_Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 65536)

a appconfig

None

Functions

f nowarning_tempnam(*args, **kw) ...

f db_differences(soClass, conn) ...

Returns the differences between a class and the table in a connection. Returns [] if no differences are found. This function does the best it can; it can miss many differences.

f register(self, command) ...

f standard_parser(connection=True, simulate=True, interactive=False, find_modules=True) ...

f update_sys_path(paths, verbose) ...

Classes

C SQLObjectVersionTable(...) ...

This table is used to store information about the database and its version (used with record and update commands).

This class contains 19 members.

C CommandRunner(...) ...

This class contains 7 members.

C Command(...) ...

This class contains 29 members.

C CommandSQL(...) ...

This class contains 32 members.

C CommandList(...) ...

This class contains 32 members.

C CommandCreate(...) ...

This class contains 32 members.

C CommandDrop(...) ...

This class contains 32 members.

C CommandStatus(...) ...

This class contains 33 members.

C CommandHelp(...) ...

This class contains 32 members.

C CommandExecute(...) ...

This class contains 33 members.

C CommandRecord(...) ...

This class contains 39 members.

C CommandUpgrade(...) ...

This class contains 43 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandDrop.html0000644000175000017500000003554412754657314026005 0ustar phdphd00000000000000

CommandDrop

The CommandDrop class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

''

a parser

<optparse.OptionParser instance at 0xb64cfb2c>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'drop'

a summary

'Drop tables'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.util.moduleloader.html0000644000175000017500000000512112754657321024346 0ustar phdphd00000000000000

moduleloader

The moduleloader module is accessible via the sqlobject.util module.

Attributes

a __package__

'sqlobject.util'

Functions

f load_module(module_name) ...

f load_module_from_name(filename, module_name) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sqlbuilder-index.html0000644000175000017500000042507112754657326024210 0ustar phdphd00000000000000 Index of sqlobject.sqlbuilder module

Index of the sqlbuilder module

SQLObject-3.1.0/docs/html/class-sqlobject.versioning.Version.html0000644000175000017500000002333712754657322024357 0ustar phdphd00000000000000

Version

The Version class is accessible via the sqlobject.versioning module.

Attributes

a childName

None

a j

version

a q

version

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f restore(self) ...

f nextVersion(self) ...

f getChangedFields(self) ...

f select(cls, clause=None, *args, **kw) ...

f __classinit__(cls, new_attrs) ...

f __init__(self, **kw) ...

f __sqlrepr__(self, db) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __getstate__(self) ...

f __setstate__(self, d) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOJsonbCol.html0000644000175000017500000002454512754657351023303 0ustar phdphd00000000000000

SOJsonbCol

The SOJsonbCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, name, soClass, creationOrder, dbName=None, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, notNone=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, unique=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None) ...

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.ConnectionHub.html0000644000175000017500000001454312754657340025751 0ustar phdphd00000000000000

ConnectionHub

This object serves as a hub for connections, so that you can pass in a ConnectionHub to a SQLObject subclass as though it was a connection, but actually bind a real database connection later. You can also bind connections on a per-thread basis.

The ConnectionHub class is accessible via the sqlobject.dbconnection module.

You must hang onto the original ConnectionHub instance, as you cannot retrieve it again from the class or instance.

To use the hub, do something like:

hub = ConnectionHub()
class MyClass(SQLObject):
    _connection = hub

hub.threadConnection = connectionFromURI('...')

Attributes

a threadConnection

<property object at 0xb670598c>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f getConnection(self) ...

f doInTransaction(self, func, *args, **kw) ...

This routine can be used to run a function in a transaction, rolling the transaction back if any exception is raised from that function, and committing otherwise.

Use like:

sqlhub.doInTransaction(process_request, os.environ)

This will run process_request(os.environ). The return value will be preserved.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.inheritance.InheritableSQLObject.html0000644000175000017500000002512012754657344026771 0ustar phdphd00000000000000

InheritableSQLObject

The InheritableSQLObject class is accessible via the sqlobject.inheritance module.

Attributes

a childName

None

a j

inheritable_sql_object

a q

inheritable_sql_object

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f set(self, **kw) ...

f __classinit__(cls, new_attrs) ...

f get(cls, id, connection=None, selectResults=None, childResults=None, childUpdate=False) ...

f select(cls, clause=None, *args, **kwargs) ...

f selectBy(cls, connection=None, **kw) ...

f destroySelf(self) ...

f __init__(self, **kw) ...

f __sqlrepr__(self, db) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __getstate__(self) ...

f __setstate__(self, d) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.events-index.html0000644000175000017500000002377112754657341023344 0ustar phdphd00000000000000 Index of sqlobject.events module

Index of the events module

  • m sqlobject.events ...
    • a __package__ ...
    • C RowCreateSignal ... - Called before an instance is created, with the class as the sender. Called with the arguments (instance, kwargs, post_funcs). There may be a connection argument. kwargs``may be usefully modified.  ``post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance).
    • C CreateTableSignal ... - Called when a table is created. If ifNotExists==True and the table exists, this event is not called.
    • C RowDestroyedSignal ... - Called after an instance is deleted. Sender is the instance's class. Arguments are (instance).
    • C AddColumnSignal ... - Called when a column is added to a class, with arguments (cls, connection, column_name, column_definition, changeSchema, post_funcs). This is called after the column has been added, and is called for each column after class creation.
    • C DeleteColumnSignal ... - Called when a column is removed from a class, with the arguments (cls, connection, column_name, so_column_obj, post_funcs). Like AddColumnSignal this is called after the action has been performed, and is called for subclassing (when a column is implicitly removed by setting it to None).
    • C DropTableSignal ... - Called when a table is dropped. If ifExists==True and the table doesn't exist, this event is not called.
    • C RowCreatedSignal ... - Called after an instance is created, with the class as the sender. Called with the arguments (instance, kwargs, post_funcs). There may be a connection argument. kwargs``may be usefully modified.  ``post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance).
    • C RowDestroySignal ... - Called before an instance is deleted. Sender is the instance's class. Arguments are (instance, post_funcs).
    • C ClassCreateSignal ... - Signal raised after class creation. The sender is the superclass (in case of multiple superclasses, the first superclass). The arguments are (new_class_name, bases, new_attrs, post_funcs, early_funcs). new_attrs is a dictionary and may be modified (but new_class_name and bases are immutable). post_funcs is an initially-empty list that can have callbacks appended to it.
    • C Signal ... - Base event for all SQLObject events.
    • C RowUpdateSignal ... - Called when an instance is updated through a call to .set() (or a column attribute assignment). The arguments are (instance, kwargs). kwargs can be modified. This is run before the instance is updated; if you want to look at the current values, simply look at instance.
    • C RowUpdatedSignal ... - Called when an instance is updated through a call to .set() (or a column attribute assignment). The arguments are (instance, post_funcs). post_funcs is a list of callbacks, intended to have functions appended to it, and are called with the arguments (new_instance). This is run after the instance is updated; Works better with lazyUpdate = True.
    • f listen ... - Listen for the given signal on the SQLObject subclass soClass, calling receiver() when send(soClass, signal, ...) is called.
SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLObjectTableWithJoins.html0000644000175000017500000004230012754657332027302 0ustar phdphd00000000000000

SQLObjectTableWithJoins

The SQLObjectTableWithJoins class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

f __init__(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mssql-index.html0000644000175000017500000002372612754657323023177 0ustar phdphd00000000000000 Index of sqlobject.mssql module

Index of the mssql module

SQLObject-3.1.0/docs/html/class-sqlobject.col.SODecimalCol.html0000644000175000017500000002347312754657352023566 0ustar phdphd00000000000000

SODecimalCol

The SODecimalCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.styles-index.html0000644000175000017500000002131612754657335023357 0ustar phdphd00000000000000 Index of sqlobject.styles module

Index of the styles module

SQLObject-3.1.0/docs/html/module-sqlobject.include.tests.test_hashcol.html0000644000175000017500000001270612754657317026175 0ustar phdphd00000000000000

test_hashcol

The test_hashcol module is accessible via the sqlobject.include.tests module.

Attributes

a items

[]

a PY2

True

a __package__

'sqlobject.include.tests'

a data

['test', 'This is more text', 'test 2']

Functions

f sha256_str(x) ...

f md5_str(x) ...

f setup() ...

f test_create() ...

f test_select() ...

Classes

C HashTest(...) ...

This class contains 20 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLTrueClauseClass.html0000644000175000017500000004111512754657332026332 0ustar phdphd00000000000000

SQLTrueClauseClass

The SQLTrueClauseClass class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sybase.sybaseconnection.html0000644000175000017500000000455112754657340025560 0ustar phdphd00000000000000

sybaseconnection

The sybaseconnection module is accessible via the sqlobject.sybase module.

Attributes

a __package__

'sqlobject.sybase'

Classes

C SybaseConnection(...) ...

This class contains 21 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.joins.OneToMany.html0000644000175000017500000001617412754657353023547 0ustar phdphd00000000000000

OneToMany

The OneToMany class is accessible via the sqlobject.joins module.

Attributes

a singleton

<bound class method OneToMany.singleton>

a clone_for_subclass

True

a declarative_count

4

a __unpackargs__

('join',)

a joinColumn

None

a __addtoclass__

<bound class method OneToMany.__addtoclass__>

a __restrict_attributes__

('join', 'joinColumn')

a __mutableattributes__

()

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __classinit__(cls, new_attrs) ...

f __instanceinit__(self, new_attrs) ...

f __init__(self, *args, **kw) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.views.html0000644000175000017500000001031412754657320022052 0ustar phdphd00000000000000

views

The views module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Functions

f isAggregate(expr) ...

Classes

C ViewSQLObjectField(...) ...

This class contains 32 members.

C ViewSQLObjectTable(...) ...

This class contains 32 members.

C ViewSQLObject(...) ...

A SQLObject class that derives all it's values from other SQLObject classes. Columns on subclasses should use SQLBuilder constructs for dbName, and sqlmeta should specify:

  • idName as a SQLBuilder construction
  • clause as SQLBuilder clause for specifying join conditions or other restrictions
  • table as an optional alternate name for the class alias

See test_views.py for simple examples.

This class contains 17 members.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.index.html0000644000175000017500000000611212754657323022030 0ustar phdphd00000000000000

index

The index module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Classes

C DatabaseIndex(...) ...

This takes a variable number of parameters, each of which is a column for indexing. Each column may be a column object or the string name of the column (not the database name). You may also use dictionaries, to further customize the indexing of the column. The dictionary may have certain keys:

'column':
The column object or string identifier.
'length':
MySQL will only index the first N characters if this is given. For other databases this is ignored.
'expression':
You can create an index based on an expression, e.g., 'lower(column)'. This can either be a string or a sqlbuilder expression.

Further keys may be added to the column specs in the future.

The class also take the keyword argument unique ; if true then a UNIQUE index is created.

This class contains 8 members.

See the source for more information.

SQLObject-3.1.0/docs/html/SQLBuilder.html0000644000175000017500000003563612754657232017433 0ustar phdphd00000000000000 SQLBuilder

SQLBuilder

A number of variables from SQLBuilder are included with from sqlobject import * -- see the relevant SQLObject documentation for more. Its functionality is also available through the special q attribute of SQLObject classes.

SQLExpression

SQLExpression uses clever overriding of operators to make Python expressions build SQL expressions -- so long as you start with a Magic Object that knows how to fake it.

With SQLObject, you get a Magic Object by accessing the q attribute of a table class -- this gives you an object that represents the field. All of this is probably easier to grasp in an example:

>>> from sqlobject.sqlbuilder import *
>>> person = table.person
# person is now equivalent to the Person.q object from the SQLObject
# documentation
>>> person
person
>>> person.first_name
person.first_name
>>> person.first_name == 'John'
person.first_name = 'John'
>>> name = 'John'
>>> person.first_name != name
person.first_name != 'John'
>>> AND(person.first_name == 'John', person.last_name == 'Doe')
(person.first_name = 'John' AND person.last_name = 'Doe')

Most of the operators work properly: <, >, <=, >=, !=, ==, +, -, /, *, **, %. However, and, or, and not do not work. You can use &, |, and ~ instead -- but be aware that these have the same precedence as multiplication. So:

# This isn't what you want:
>> person.first_name == 'John' & person.last_name == 'Doe'
(person.first_name = ('John' AND person.last_name)) = 'Doe')
# This is:
>> (person.first_name == 'John') & (person.last_name == 'Doe')
((person.first_name = 'John') AND (person.last_name == 'Doe'))

SQLBuilder also contains the functions AND, OR, and NOT which also work -- I find these easier to work with. AND and OR can take any number of arguments.

You can also use .startswith() and .endswith() on an SQL expression -- these will translate to appropriate LIKE statements and all % quoting is handled for you, so you can ignore that implementation detail. There is also a LIKE function, where you can pass your string, with % for the wildcard, as usual.

If you want to access an SQL function, use the func variable, like:

>> person.created < func.NOW()

To pass a constant, use the const variable which is actually an alias for func.

SQL statements

SQLBuilder implements objects that execute SQL statements. SQLObject uses them internally in its higher-level API, but users can use this mid-level API to execute SQL queries that are not supported by the high-level API. To use these objects first construct an instance of a statement object, then ask the connection to convert the instance to an SQL query and finally ask the connection to execute the query and return the results. For example, for Select class:

>>> from sqlobject.sqlbuilder import *
>> select = Select(['name', 'AVG(salary)'], staticTables=['employees'],
>>     groupBy='name') # create an instance
>> query = connection.sqlrepr(select) # Convert to SQL string:
>>     # SELECT name, AVG(salary) FROM employees GROUP BY name
>> rows = connection.queryAll(query) # Execute the query
>>     # and get back the results as a list of rows
>>     # where every row is a sequence of length 2 (name and average salary)

Select

A class to build SELECT queries. Accepts a number of parameters, all parameters except items are optional. Use connection.queryAll(query) to execute the query and get back the results as a list of rows.

items:
A string, an SQLExpression or a sequence of strings or SQLExpression's, represents the list of columns. If there are q-values SQLExpression's Select derives a list of tables for SELECT query.
where:
A string or an SQLExpression, represents the WHERE clause.
groupBy:
A string or an SQLExpression, represents the GROUP BY clause.
having:
A string or an SQLExpression, represents the HAVING part of the GROUP BY clause.
orderBy:
A string or an SQLExpression, represents the ORDER BY clause.
join:
A (list of) JOINs (LEFT JOIN, etc.)
distinct:
A bool flag to turn on DISTINCT query.
start, end:
Integers. The way to calculate OFFSET and LIMIT.
limit:
An integer. limit, if passed, overrides end.
reversed:
A bool flag to do ORDER BY in the reverse direction.
forUpdate:
A bool flag to turn on SELECT FOR UPDATE query.
staticTables:
A sequence of strings or SQLExpression's that name tables for FROM. This parameter must be used if items is a list of strings from which Select cannot derive the list of tables.

Insert

A class to build INSERT queries. Accepts a number of parameters. Use connection.query(query) to execute the query.

table:
A string that names the table to INSERT into. Required.
valueList:

A list of (key, value) sequences or {key: value} dictionaries; keys are column names. Either valueList or values must be passed, but not both. Example:

>> insert = Insert('person', valueList=[('name', 'Test'), ('age', 42)])
       # or
>> insert = Insert('person', valueList=[{'name': 'Test'}, {'age': 42}])
>> query = connection.sqlrepr(insert)
       # Both generate the same query:
       # INSERT INTO person (name, age) VALUES ('Test', 42)
>> connection.query(query)
values:

A dictionary {key: value}; keys are column names. Either valueList or values must be passed, but not both. Example:

>> insert = Insert('person', values={'name': 'Test', 'age': 42})
>> query = connection.sqlrepr(insert)
       # The query is the same
       # INSERT INTO person (name, age) VALUES ('Test', 42)
>> connection.query(query)

Instances of the class work fast and thus are suitable for mass-insertion. If one needs to populate a database with SQLObject running a lot of INSERT queries this class is the way to go.

Update

A class to build UPDATE queries. Accepts a number of parameters. Use connection.query(query) to execute the query.

table:
A string that names the table to UPDATE. Required.
values:
A dictionary {key: value}; keys are column names. Required.
where:
An optional string or SQLExpression, represents the WHERE clause.

Example:

>> update = Update('person',
>>     values={'name': 'Test', 'age': 42}, where='id=1')
>> query = connection.sqlrepr(update)
       # UPDATE person SET name='Test', age=42 WHERE id=1
>> connection.query(query)

Delete

A class to build DELETE FROM queries. Accepts a number of parameters. Use connection.query(query) to execute the query.

table:
A string that names the table to UPDATE. Required.
where:
An optional string or an SQLExpression, represents the WHERE clause. Required. If you need to delete all rows pass where=None; this is a safety measure.

Example:

>> update = Delete('person', where='id=1')
>> query = connection.sqlrepr(update)
       # DELETE FROM person WHERE id=1
>> connection.query(query)

Union

A class to build UNION queries. Accepts a number of parameters - Select queries. Use connection.queryAll(query) to execute the query and get back the results.

Example:

>> select1 = Select(['min', func.MIN(const.salary)], staticTables=['employees'])
>> select2 = Select(['max', func.MAX(const.salary)], staticTables=['employees'])
>> union = Union(select1, select2)
>> query = connection.sqlrepr(union)
       # SELECT 'min', MIN(salary) FROM employees
       #    UNION
       # SELECT 'max', MAX(salary) FROM employees
>> rows = connection.queryAll(query)

Nested SQL statements (subqueries)

There are a few special operators that receive as parameter SQL statements. These are IN, NOTIN, EXISTS, NOTEXISTS, SOME, ANY and ALL. Consider the following example: You are interested in removing records from a table using deleteMany. However, the criterion for doing so depends on another table.

You would expect the following to work:

>> PersonWorkplace.deleteMany(where=
   ((PersonWorkplace.q.WorkplaceID==Workplace.q.id) &
   (Workplace.q.id==SOME_ID)))

But this doesn't work! However, you can't do a join in a deleteMany call. To work around this issue, use IN:

>> PersonWorkplace.deleteMany(where=
   IN(PersonWorkplace.q.WorkplaceID,
   Select(Workplace.q.id, Workplace.q.id==SOME_ID)))
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.RLIKE.html0000644000175000017500000004242212754657331023557 0ustar phdphd00000000000000

RLIKE

The RLIKE class is accessible via the sqlobject.sqlbuilder module.

Attributes

a op_db

{'firebird': 'RLIKE',
 'maxdb': 'RLIKE',
 'mysql': 'RLIKE',
 'postgres': '~',
 'rdbhost': '~',
 'sqlite': 'REGEXP'}

a op

'RLIKE'

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, expr, string, escape=None) ...

f components(self) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOSmallIntCol.html0000644000175000017500000002433512754657352023751 0ustar phdphd00000000000000

SOSmallIntCol

The SOSmallIntCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

f addSQLAttrs(self, str) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.MediumIntCol.html0000644000175000017500000000754312754657350023657 0ustar phdphd00000000000000

MediumIntCol

The MediumIntCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/sqlobject-admin.html0000644000175000017500000003500512754657233020530 0ustar phdphd00000000000000 The sqlobject-admin Tool

The sqlobject-admin Tool

Author: Ian Bicking <ianb@colorstudy.com>
Revision: $Rev$
Date: $LastChangedDate$

Warning

This document isn't entirely accurate; some of what it describes are the intended features of the tool, not the actual features.

Particularly inaccurate is how modules and classes are found.

Introduction

The sqlobject-admin tool included with SQLObject allows you to manage your database as defined with SQLObject classes.

Some of the features include creating tables, checking the status of the database, recording a version of a schema, and updating the database to match the version of the schema in your code.

To see a list of commands run sqlobject-admin help. Each sub-command has -h option which explains the details of that command.

Common Options

Many of the commands share some common options, mostly for finding the database and classes.

-c CONNECTION or --connection=CONNECTION:

This takes an argument, the connection string for the database. This overrides any connection the classes have (if they are hardwired to a connection).

-f FILENAME or --config-file=FILENAME:

This is a configuration file from which to get the connection. This configuration file should be a Python-syntax file that defines a global variable database, which is the connection string for the database.

-m MODULE or --module=MODULE:

A module to look in for classes. MODULE is something like myapp.amodule. Remember to set your $PYTHONPATH if the module can't be imported. You can provide this argument multiple times.

-p PACKAGE or --package=PACKAGE:

A package to look in. This looks in all the modules in this class and subclasses for SQLObject classes.

--class=CLASSMATCH:

This restricts the classes found to the matching classes. You may use wildcards. You can provide multiple --class arguments, and if any pattern matches the class will be included.

--egg=EGG_SPEC:

This is an Egg description that should be loaded. So if you give --egg=ProjectName it'll load that egg, and look in ProjectName.egg-info/sqlobject.txt for some settings (like db_module and history_dir).

When finding SQLObject classes, we look in the modules for classes that belong to the module -- so if you import a class from another module it won't be "matched". You have to indicate its original module.

If classes have to be handled in a specific order, create a soClasses global variable that holds a list of the classes. This overrides the module restrictions. This is important in databases with referential integrity, where dependent tables can't be created before the tables they depend on.

The create Command

This finds the tables and creates them. Any tables that exist are simply skipped.

It also collects data from sqlmeta.createSQL (added in svn trunk) and runs the queries after table creation. createSQL can be a string with a single SQL command, a list of SQL commands, or a dictionary with keys that are dbNames and values that are either single SQL command string or a list of SQL commands. An example follows:

class MyTable(SQLObject):
    class sqlmeta:
        createSQL = {'postgres': [
            "ALTER TABLE my_table ADD CHECK(my_field != '');",
            ]}
    myField = StringCol()

The sql Command

This shows the SQL to create all the tables.

The drop Command

Drops tables! Missing tables are skipped.

The execute Command

This executes an arbitrary SQL expression. This is mostly useful if you want to run a query against a database described by a SQLObject connection string. Use --stdin if you want to pipe commands in; otherwise you give the commands as arguments.

The list Command

Lists out all the classes found. This can help you figure out what classes you are dealing with, and if there's any missing that you expected.

The status Command

This shows if tables are present in the database. If possible (it depends on the database) it will also show if the tables are missing any columns, or have any extra columns, when compared to the table the SQLObject class describes. It doesn't check column types, indexes, or constraints. This feature may be added in the future.

Versioning & Upgrading

There's two commands related to storing the schema and upgrading the database: record and upgrade.

The idea is that you record each iteration of your schema, and this gets a version number. Something like 2003-05-04a. If you are using source control you'll check all versions into your repository; you don't overwrite one with the next.

In addition to the on-disk record of the different schemas you have gone through, the database itself contains a record of what version it is at. By having all the versions available at once, we can upgrade from any version. But more on that later

Basic Usage

Here's a quick summary of how you use these commands:

  1. In project where you've never used sqlobject-admin before, you run sqlobject-admin record --output-dir=sqlobject-history. If your active database is up-to-date with the code, then the tool will add a sqlobject_db_version table to the database with the current version.
  2. Now, make some updates to your code. Don't update the database! (You could, but for now it's more fun if you don't.)
  3. Run sqlobject-admin record --edit. A new version will be created, and an editor will be opened up.

The record Command

Record will take the SQL CREATE statements for your tables, and output them in new version. It creates the version by using the ISO-formatted date (YYYY-MM-DD) and a suffix to make it unique. It puts each table in its own file.

This normally doesn't touch the database at all -- it only records the schema as defined in your code, regardless of the database. In fact, I recommend calling record before you update your database.

The upgrade Command

Future

  • Get record to do svn cp when creating a new version, then write over those files; this way the version control system will have nice diffs.
  • An option to record the SQL for multiple database backends at once (now only the active backend is recorded).
  • An option to upgrade databases with Python scripts instead of SQL commands. Or a little of both.
  • Review all the verbosity, maybe add logging, review simulation.
  • Generate simple ALTER statements for upgrade scripts, to give people something to work with. Maybe.
  • A command to trim versions, by merging upgrade scripts.
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.col.BLOBCol.html0000644000175000017500000000750212754657350022475 0ustar phdphd00000000000000

BLOBCol

The BLOBCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.maxdb.maxdbconnection.LowerBoundOfSliceIsNotSupported.html0000644000175000017500000001404512754657343033223 0ustar phdphd00000000000000

LowerBoundOfSliceIsNotSupported

The LowerBoundOfSliceIsNotSupported class is accessible via the sqlobject.maxdb.maxdbconnection module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/Python3.html0000644000175000017500000001436312754657232017023 0ustar phdphd00000000000000 SQLObject and Python 3

SQLObject and Python 3

Changes between Python 2 and Python 3

There are a few changes in the behaviour of SQLObject on Python 3, due to the changed stings / bytes handling introduced in Python 3.0.

BLOBCol

In Python 3, BLOBCol now accepts and returns bytes, rather than strings as it did in Python 2.

StringCol

In Python 3, StringCol now accepts arbitrary Unicode strings.

UnicodeCol

The dbEncoding parameter to UnicodeCol has no effect in Python 3 code. This is now handled by the underlying database layer and is no longer exposed via SQLObject. The parameter is still available for those writing Python 2 compatible code.

Python 3 and MySQL

SQLObject is tested using mysqlclient as the database driver on Python 3. Note that the default encoding of MySQL databases is latin1, which can cause problems with general Unicode strings. We recommend specifying the character set as utf8 when using MySQL to protect against these issues.

Using databases created with SQLObject and Python 2 in Python 3

For most cases, things should just work as before. The only issues should around UnicodeCol, as how this is handled has changed.

SQLite

The Python 3 sqlite driver expects Unicode columns to be encoded using utf8. Columns created using the default encoding on Python 2 should work fine, but columns created with a different encoding set using the dbEncoding parameter may cause problems.

Postgres

Postgres' behaviour is similar to sqlite. Columns created using the default encoding on Python 2 should work fine, but columns created with a different encoding set using the dbEncoding may cause problems.

MySQL

For MySQL, the results depend on whether the Python 2 database was using MySQLdb's Unicode mode or not.

If a character set was specified for the database using the charset parameter, such as:

mysql:///localhost/test?charset=latin1

Things should work provided the same character set is specified when using Python 3.

If a character set wasn't specified, then things may work if the character set is set to match the dbEncoding parameter used when defining the UnicodeCol.

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.dbconnection-index.html0000644000175000017500000006256512754657337024516 0ustar phdphd00000000000000 Index of sqlobject.dbconnection module

Index of the dbconnection module

SQLObject-3.1.0/docs/html/module-sqlobject.constraints.html0000644000175000017500000001324012754657323023270 0ustar phdphd00000000000000

constraints

Constraints

The constraints module is accessible via the sqlobject module.

Attributes

a PY2

True

a __package__

'sqlobject'

Functions

f isString(obj, col, value) ...

f notNull(obj, col, value) ...

f isInt(obj, col, value) ...

f isFloat(obj, col, value) ...

f isBool(obj, col, value) ...

Classes

C BadValue(...) ...

This class contains 10 members.

C InList(...) ...

This class contains 2 members.

C MaxLength(...) ...

This class contains 2 members.

See the source for more information.

SQLObject-3.1.0/docs/html/site.css0000644000175000017500000001050512754657230016237 0ustar phdphd00000000000000 /* This is a generated, using these settings: {'nav_container_color': '#79f', 'nav_border_color': '#05f', 'body_outer_bg_color': '#46a', 'nav_button_color': '#037', 'visited_color': '#093', 'body_border_color': '#09f', 'link1': 'SQLObject.html Documentation', 'normal_link_color': '#039', 'hover_color': '#ddf', 'no_about': 'true'} */ i, em { font-family: Times New Roman,Times,serif; } a { font-weight: bold; } a:link { color: #039; } a:visited { color: #093; } a:hover { background-color: #ddf; } /* Theme Name: Almodovar Theme URI: http://blog.ratterobert.com/archiv/2005/03/09/almodovar/ Description: Das Theme basiert im Ursprung auf Michael Heilemanns Kubrick-Template und ist von dem einen oder anderen Gimmick anderer sehr guter Templates inspiriert worden. Version: 0.7 Author: ratte / robert Author URI: http://blog.ratterobert.com/ */ /* Begin Typography & Colors */ body { font-family: 'Lucida Grande', 'Trebuchet MS', 'Bitstream Vera Sans', Sans-Serif; background-color: #46a; text-align: center; } #page { background-color: #fff; border: 2px solid #09f; text-align: left; } #content { margin: 0; } #content p, #content ul, #content blockquote { /*line-height: 1.6em;*/ } #footer { border-top: 1px solid #000; margin-top: 2em; color: #666; font-size: 75%; } #footer a:link, #footer a:visited { font-weight: normal; } small { font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 0.9em; line-height: 1.5em; } h1, h2, h3 { font-family: 'Trebuchet MS', 'Lucida Grande', Verdana, Arial, Sans-Serif; font-weight: bold; margin-top: .7em; margin-bottom: .7em; } h1 { font-size: 2.0em; } h2 { font-size: 1.75em; } h3 { font-size: 1.25em; } div#content h1, div#content h2, div#content h3 { color: #555; border-bottom: 2px solid #f95_; } h1 a, h2 a, h3 a { color: #555; } h1, h1 a, h1 a:hover, h1 a:visited, h2, h2 a, h2 a:hover, h2 a:visited, h3, h3 a, h3 a:hover, h3 a:visited, cite { text-decoration: none; } small, blockquote, strike { color: #444; } #links ul ul li, #links li { list-style: none; } code { font: 1.1em 'Courier', 'Courier New', Fixed; } acronym, abbr, span.caps { font-size: 0.9em; letter-spacing: .07em; } /* Special case doc-title */ h1.doc-title { font-variant: small-caps; letter-spacing: 0.25em; font-size: 2em; margin: 0; } h1.doc-title a { display: block; padding-left: 0.8em; padding-bottom: .5em; padding-top: .5em; margin: 0; border-bottom: 1px #fff solid; } h1.doc-title, h1.doc-title a, h1.doc-title a:visited, h1.doc-title a:hover { text-decoration: none; color: #ff5000; } /* End Typography & Colors */ /* Begin Structure */ body { margin: 0; padding: 0; } #page { background-color: white; margin: 0 auto 0 5em; padding: 0; max-width: 60em; border: 1px solid #959596; } * html #page { width: 60em; } #content { margin: 0 1em 0 3em; } #content h1 { margin-left: 0; } #footer { padding: 0 0 0 1px; margin: 0; margin-top: 1.5em; clear: both; } #footer p { margin: 1em; } /* End Structure */ /* Begin Headers */ .description { text-align: center; } /* End Headers */ /* Begin Form Elements */ #searchform { margin: 1em auto; text-align: right; } #searchform #s { width: 100px; padding: 2px; } #searchsubmit { padding: 1px; } /* End Form Elements */ /* Begin Various Tags & Classes */ acronym, abbr, span.caps { cursor: help; } acronym, abbr { border-bottom: 1px dashed #999; } blockquote { margin: 15px 30px 0 10px; padding-left: 20px; border-left: 5px solid #ccc; } blockquote cite { margin: 5px 0 0; display: block; } hr { display: none; } a img { border: none; } .navigation { display: block; text-align: center; margin-top: 10px; margin-bottom: 60px; } /* End Various Tags & Classes*/ span a { color: #CCC; } span a:hover { color: #FF5000; } #navcontainer { margin-top: 0px; padding-top: 0px; width: 100%; background-color: #79f; text-align: right; } #navlist ul { margin-left: 0; margin-right: 5px; padding-left: 0; white-space: nowrap; } #navlist li { display: inline; list-style-type: none; } #navlist a { padding: 3px 10px; color: #fff; background-color: #037; text-decoration: none; border: 1px solid #05f; font-weight: normal; } #navlist a:hover { color: #000; background-color: #fff; text-decoration: none; font-weight: normal; } SQLObject-3.1.0/docs/html/class-sqlobject.col.Col.html0000644000175000017500000000743312754657352022043 0ustar phdphd00000000000000

Col

The Col class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-index.html0000644000175000017500000001613212754657233020046 0ustar phdphd00000000000000 SQLObject -- Module Reference

SQLObject

Module Reference

Packages and Modules

sqlobject
SQLObject
sqlobject.manager
sqlobject.mysql
sqlobject.cache
This implements the instance caching in SQLObject. Caching is relatively aggressive. All objects are retained so long as they are in memory, by keeping weak references to objects. We also keep other objects in a cache that doesn't allow them to be garbage collected (unless caching is turned off).
sqlobject.main
sqlobject.postgres
sqlobject.views
sqlobject.util
sqlobject.versioning
sqlobject.dberrors
dberrors: database exception classes for SQLObject.
sqlobject.constraints
Constraints
sqlobject.index
sqlobject.rdbhost
sqlobject.mssql
sqlobject.sqlbuilder
sqlobject.firebird
sqlobject.converters
sqlobject.classregistry
classresolver.py
2 February 2004, Ian Bicking <ianb@colorstudy.com>
sqlobject.include
sqlobject.boundattributes
Bound attributes are attributes that are bound to a specific class and a specific name. In SQLObject a typical example is a column object, which knows its name and class.
sqlobject.styles
sqlobject.sqlite
sqlobject.dbconnection
sqlobject.sybase
sqlobject.__version__
sqlobject.events
sqlobject.compat
sqlobject.maxdb
sqlobject.declarative
Declarative objects.
sqlobject.sresults
sqlobject.col
Col -- SQLObject columns
sqlobject.inheritance
sqlobject.joins
SQLObject-3.1.0/docs/html/module-sqlobject.cache.html0000644000175000017500000000711412754657316021771 0ustar phdphd00000000000000

cache

This implements the instance caching in SQLObject. Caching is relatively aggressive. All objects are retained so long as they are in memory, by keeping weak references to objects. We also keep other objects in a cache that doesn't allow them to be garbage collected (unless caching is turned off).

The cache module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Classes

C CacheFactory(...) ...

CacheFactory caches object creation. Each object should be referenced by a single hashable ID (note tuples of hashable values are also hashable).

This class contains 15 members.

C CacheSet(...) ...

A CacheSet is used to collect and maintain a series of caches. In SQLObject, there is one CacheSet per connection, and one Cache in the CacheSet for each class, since IDs are not unique across classes. It contains methods similar to Cache, but that take a cls argument.

This class contains 17 members.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.compat.html0000644000175000017500000000537512754657342022217 0ustar phdphd00000000000000

compat

The compat module is accessible via the sqlobject module.

Attributes

a PY2

True

a __package__

'sqlobject'

a class_types

(<type 'type'>, <type 'classobj'>)

Functions

f with_metaclass(meta, *bases) ...

Create a base class with a metaclass.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.maxdb.maxdbconnection.MaxdbConnection.html0000644000175000017500000002713312754657343030070 0ustar phdphd00000000000000

MaxdbConnection

The MaxdbConnection class is accessible via the sqlobject.maxdb.maxdbconnection module.

Attributes

a supportTransactions

True

a schemes

['maxdb']

a GET_PK_AND_FK

"\n    SELECT constraint_cols.column_name, constraints.constraint_type,\n           refname,reftablename\n    FROM user_cons_columns constraint_cols\n    INNER JOIN user_constraints constraints\n    ON constraint_cols.constraint_name = constraints.constraint_name\n    LEFT OUTER JOIN show_foreign_key fk\n    ON constraint_cols.column_name = fk.columnname\n    WHERE constraints.table_name =UPPER('%s')"

a GET_COLUMNS

"\n    SELECT COLUMN_NAME, NULLABLE, DATA_DEFAULT, DATA_TYPE,\n           DATA_LENGTH, DATA_SCALE\n    FROM USER_TAB_COLUMNS WHERE TABLE_NAME=UPPER('%s')"

a dbName

'maxdb'

Methods

f __init__(self, host='', port=None, user=None, password=None, database=None, autoCommit=1, sqlmode='internal', isolation=None, timeout=None, **kw) ...

f createSequenceName(self, table) ...

sequence name are builded with the concatenation of the table name with '_SEQ' word we truncate the name of the sequence_name because sapdb identifier cannot exceed 32 characters so that the name of the sequence does not exceed 32 characters

f makeConnection(self) ...

f sqlAddLimit(cls, query, limit) ...

f createTable(self, soClass) ...

f createReferenceConstraint(self, soClass, col) ...

f createColumn(self, soClass, col) ...

f createIDColumn(self, soClass) ...

f createIndexSQL(self, soClass, index) ...

f dropTable(self, tableName, cascade=False) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f addColumn(self, tableName, column) ...

f delColumn(self, sqlmeta, column) ...

f columnsFromSchema(self, tableName, soClass) ...

f guessClass(self, t, flength, fscale=None) ...

An internal method that tries to figure out what Col subclass is appropriate given whatever introspective information is available -- both very database-specific.

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Update.html0000644000175000017500000004120412754657327024135 0ustar phdphd00000000000000

Update

The Update class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table, values, template=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, where=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>) ...

f __sqlrepr__(self, db) ...

f sqlName(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.DESC.html0000644000175000017500000004003412754657333023426 0ustar phdphd00000000000000

DESC

The DESC class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, expr) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.rdbhost.html0000644000175000017500000000476712754657323022404 0ustar phdphd00000000000000

rdbhost

The rdbhost module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.rdbhost'

Functions

f builder() ...

Modules

The sqlobject.rdbhost module exposes 1 submodules:

rdbhostconnection
This module written by David Keeney, 2009, 2010

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.TableSpace.html0000644000175000017500000000173612754657330024716 0ustar phdphd00000000000000

TableSpace

The TableSpace class is accessible via the sqlobject.sqlbuilder module.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.dbconnection.html0000644000175000017500000003001012754657337023365 0ustar phdphd00000000000000

dbconnection

The dbconnection module is accessible via the sqlobject module.

Attributes

a PY2

True

a __package__

'sqlobject'

a TheURIOpener

<sqlobject.dbconnection.ConnectionURIOpener object at 0xb672c94c>

Functions

f makeDebugWriter(connection, loggerName, loglevel) ...

f registerConnection(self, schemes, builder) ...

f registerConnectionInstance(self, inst) ...

f connectionForURI(self, uri, oldUri=False, **args) ...

f dbConnectionForScheme(self, scheme) ...

Classes

C ConsoleWriter(...) ...

This class contains 2 members.

C LogWriter(...) ...

This class contains 2 members.

C Boolean(...) ...

A bool class that also understands some special string keywords

Understands: yes/no, true/false, on/off, 1/0, case ignored.

This class contains 4 members.

C DBConnection(...) ...

This class contains 7 members.

C ConnWrapper(...) ...

This represents a SQLObject class that is bound to a specific connection (instances have a connection instance variable, but classes are global, so this is binds the connection variable lazily when a class method is accessed)

This class contains 5 members.

C ConnMethodWrapper(...) ...

This class contains 5 members.

C DBAPI(...) ...

Subclass must define a makeConnection() method, which returns a newly-created connection object.

queryInsertID must also be defined.

This class contains 35 members.

C Iteration(...) ...

This class contains 8 members.

C Transaction(...) ...

This class contains 15 members.

C ConnectionHub(...) ...

This object serves as a hub for connections, so that you can pass in a ConnectionHub to a SQLObject subclass as though it was a connection, but actually bind a real database connection later. You can also bind connections on a per-thread basis.

You must hang onto the original ConnectionHub instance, as you cannot retrieve it again from the class or instance.

To use the hub, do something like:

hub = ConnectionHub()
class MyClass(SQLObject):
    _connection = hub

hub.threadConnection = connectionFromURI('...')

This class contains 9 members.

C ConnectionURIOpener(...) ...

This class contains 8 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.ImportProxyField.html0000644000175000017500000004172312754657331026174 0ustar phdphd00000000000000

ImportProxyField

The ImportProxyField class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

f __init__(self, tableName, fieldName, original, soClass, column) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsedImmediate(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.Error.html0000644000175000017500000001316212754657322023455 0ustar phdphd00000000000000

Error

The Error class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.col-index.html0000644000175000017500000022314412754657346022616 0ustar phdphd00000000000000 Index of sqlobject.col module

Index of the col module

SQLObject-3.1.0/docs/html/module-sqlobject.dberrors-index.html0000644000175000017500000001353112754657322023652 0ustar phdphd00000000000000 Index of sqlobject.dberrors module

Index of the dberrors module

SQLObject-3.1.0/docs/html/News4.html0000644000175000017500000004207612754657232016461 0ustar phdphd00000000000000 News

News

SQLObject 0.15.1

Released 22 Mar 2011.

  • A bug was fixed in MSSQLConnection.
  • A minor bug was fixed in sqlbuilder.Union.

SQLObject 0.15.0

Released 6 Dec 2010.

Features & Interface

  • Major API change: all signals are sent with the instance (or the class) as the first parameter. The following signals were changed: RowCreateSignal, RowCreatedSignal, DeleteColumnSignal.
  • Major API change: post-processing functions for all signals are called with the instance as the first parameter. The following signals were changed: RowUpdatedSignal, RowDestroySignal, RowDestroyedSignal.

SQLObject 0.14.2

  • A minor bug was fixed in sqlbuilder.Union.

SQLObject 0.14.1

Released 15 Oct 2010.

SQLObject 0.14.0

Released 10 Oct 2010.

Features & Interface

  • The lists of columns/indices/joins are now sorted according to the order of declaration.
  • validator2 was added to all columns; it is inserted at the beginning of the list of validators, i.e. its from_python() method is called first, to_python() is called last, after all validators in the list.
  • SQLiteConnection's parameter use_table_info became boolean with default value True; this means the default schema parser is now based on PRAGMA table_info().
  • Major API change: attribute dirty was moved to sqlmeta.

SQLObject 0.13.1

Released 15 Oct 2010.

  • A bug was fixed in a subtle case when a per-instance connection is not passed to validators.

SQLObject 0.13.0

Released 11 Aug 2010.

Features & Interface

  • SQLObject instances that don't have a per-instance connection can be pickled and unpickled.
  • Validators became stricter: StringCol and UnicodeCol now accept only str, unicode or an instance of a class that implements __unicode__ (but not __str__ because every object has a __str__ method); BoolCol accepts only bool or int or an instance of a class that implements __nonzero__; IntCol accepts int, long or an instance of a class that implements __int__ or __long__; FloatCol accepts float, int, long or an instance of a class that implements __float__, __int__ or __long__.
  • Added a connection class for rdbhost.com (commercial Postgres-over-Web service).

Small Features

  • Added TimedeltaCol; currently it's only implemented on PostgreSQL as an INTERVAL type.
  • Do not pollute the base sqlmeta class to allow Style to set idName. In the case of inherited idName inherited value takes precedence; to allow Style to set idName reset inherited idName to None.
  • Better handling of circular dependencies in sqlobject-admin - do not include the class in the list of other classes.
  • Renamed db_encoding to dbEncoding in UnicodeStringValidator.
  • A new parameter sslmode was added to PostgresConnection.
  • Removed SQLValidator - its attemptConvert was never called because in FormEncode it's named attempt_convert.

SQLObject 0.12.5

  • backend parameter was renamed to driver. To preserve backward compatibility backend is still recognized and will be recognized for some time.

SQLObject 0.12.4

Released 5 May 2010.

  • Bugs were fixed in calling from_python().
  • A bugfix was ported from SQLObject 0.11.6.

SQLObject 0.12.3

Released 11 Apr 2010.

SQLObject 0.12.2

Released 4 Mar 2010.

SQLObject 0.12.1

Released 8 Jan 2010.

  • Fixed three bugs in PostgresConnection.
  • A number of changes ported from SQLObject 0.11.3.

SQLObject 0.12

Released 20 Oct 2009.

Features & Interface

  • .selectBy(), .deleteBy() and .by*() methods pass all values through .from_python(), not only unicode.
  • The user can choose a DB API driver for SQLite by using a backend parameter in DB URI or SQLiteConnection that can be a comma-separated list of backend names. Possible backends are: pysqlite2 (alias sqlite2), sqlite3, sqlite (alias sqlite1). Default is to test pysqlite2, sqlite3 and sqlite in that order.
  • The user can choose a DB API driver for PostgreSQL by using a backend parameter in DB URI or PostgresConnection that can be a comma-separated list of backend names. Possible backends are: psycopg2, psycopg1, psycopg (tries psycopg2 and psycopg1), pygresql. Default is psycopg. WARNING: API change! PostgresConnection's parameter usePygresql is now replaced with backend=pygresql.
  • The user can choose a DB API driver for MSSQL by using a backend parameter in DB URI or MSSQLConnection that can be a comma-separated list of backend names. Possible backends are: adodb (alias adodbapi) and pymssql. Default is to test adodbapi and pymssql in that order.
  • alternateMethodName is defined for all unique fields, not only alternateID; this makes SQLObject create .by*() methods for all unique fields.
  • SET client_encoding for PostgreSQL to the value of charset parameter in DB URI or PostgresConnection.
  • TimestampCol() can be instantiated without any defaults, in this case default will be None (good default for TIMESTAMP columns in MySQL).

Small Features

  • Imported DB API drivers are stored as connection instance variables, not in global variables; this allows to use different DB API drivers at the same time; for example, PySQLite2 and sqlite3.
  • Removed all deprecated attributes and functions.
  • Removed the last remained string exceptions.

SQLObject 0.11.6

Released 5 May 2010.

  • A bug was fixed in SQLiteConnection.columnsFromSchema(): pass None as size/precision to DecimalCol; DecimalCol doesn't allow default values (to force user to pass meaningful values); but columnsFromSchema() doesn't implement proper parsing of column details.

SQLObject 0.11.5

Released 11 Apr 2010.

  • Fixed a bug in replacing _connection in a case when no previous _connection has been set.

SQLObject 0.11.4

Released 4 Mar 2010.

  • Fixed a bug in inheritance - if creation of the row failed and if the connection is not a transaction and is in autocommit mode - remove parent row(s).
  • Do not set _perConnection flag if get() or _init() is passed the same connection; this is often the case with select().

SQLObject 0.11.3

Released 8 Jan 2010.

  • Fixed a bug in col.py and dbconnection.py - if dbEncoding is None suppose it's 'ascii'.
  • Fixed a bug in FirebirdConnection.
  • The cache culling algorithm was enhanced to eliminate memory leaks by removing references to dead objects; tested on a website that runs around 4 million requests a day.

SQLObject 0.11.2

Released 30 Sep 2009.

  • Fixed a bug in logging to console - convert unicode to str.
  • Fixed an obscure bug in ConnectionHub triggered by an SQLObject class whose instances can be coerced to boolean False.

SQLObject 0.11.1

Released 20 Sep 2009.

  • Fixed a bug: Sybase tables with identity column fire two identity_inserts.
  • Fixed a bug: q.startswith(), q.contains() and q.endswith() escape (with a backslash) all special characters (backslashes, underscores and percent signs).

SQLObject 0.11.0

Released 12 Aug 2009.

Features & Interface

  • Dropped support for Python 2.3. The minimal version of Python for SQLObject is 2.4 now.
  • Dropped support for PostgreSQL 7.2. The minimal supported version of PostgreSQL is 7.3 now.
  • New magic attribute j similar to q was added that automagically does join with the other table in MultipleJoin or RelatedJoin.
  • SQLObject can now create and drop a database in MySQL, PostgreSQL, SQLite and Firebird/Interbase.
  • Added some support for schemas in PostgreSQL.
  • Added DecimalStringCol - similar to DecimalCol but stores data as strings to work around problems in some drivers and type affinity problem in SQLite.
  • Added sqlobject.include.hashcol.HashCol - a column type that automatically hashes anything going into it, and returns out an object that hashes anything being compared to itself. Basically, it's good for really simple one-way password fields, and it even supports the assignment of None to indicate no password set. By default, it uses the md5 library for hashing, but this can be changed in a HashCol definition.
  • RowDestroyedSignal and RowUpdatedSignal were added.

Minor features

  • Use reversed() in manager/command.py instead of .__reversed__().
  • Minor change in logging to console - logger no longer stores the output file, it gets the file from module sys every time by name; this means logging will use new sys.stdout (or stderr) in case the user changed them.
  • Changed the order of testing of SQLite modules - look for external PySQLite2 before sqlite3.

Older news

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.util.csvimport.html0000644000175000017500000001613112754657321023723 0ustar phdphd00000000000000

csvimport

Import from a CSV file or directory of files.

The csvimport module is accessible via the sqlobject.util module.

CSV files should have a header line that lists columns. Headers can also be appended with :type to indicate the type of the field. escaped is the default, though it can be overridden by the importer. Supported types:

:python:
A python expression, run through eval(). This can be a security risk, pass in allow_python=False if you don't want to allow it.
:int:
Integer
:float:
Float
:str:
String
:escaped:
A string with backslash escapes (note that you don't put quotation marks around the value)
:base64:
A base64-encoded string
:date:
ISO date, like YYYY-MM-DD; this can also be NOW+days or NOW-days
:datetime:
ISO date/time like YYYY-MM-DDTHH:MM:SS (either T or a space can be used to separate the time, and seconds are optional). This can also be NOW+seconds or NOW-seconds
:bool:
Converts true/false/yes/no/on/off/1/0 to boolean value
:ref:
This will be resolved to the ID of the object named in this column (None if the column is empty). @@: Since there's no ordering, there's no way to promise the object already exists.

You can also get back references to the objects if you have a special [name] column.

Any column named [comment] or with no name will be ignored.

In any column you can put [default] to exclude the value and use whatever default the class wants. [null] will use NULL.

Lines that begin with [comment] are ignored.

Attributes

a __package__

'sqlobject.util'

Functions

f create_data(data, class_getter, keyorder=None) ...

Create the data, which is the return value from load_csv(). Classes will be resolved with the callable class_getter; or if class_getter is a module then the class names will be attributes of that.

Returns a dictionary of {object_name: object(s)}, using the names from the [name] columns (if there are any). If a name is used multiple times, you get a list of objects, not a single object.

If keyorder is given, then the keys will be retrieved in that order. It can be a list/tuple of names, or a sorting function. If not given and class_getter is a module and has a soClasses function, then that will be used for the order.

f load_csv_from_directory(directory, allow_python=True, default_type='escaped', allow_multiple_classes=True) ...

Load the data from all the files in a directory. Filenames indicate the class, with general.csv for data not associated with a class. Return data just like load_csv does.

This might cause problems on case-insensitive filesystems.

f load_csv(csvreader, allow_python=True, default_type='escaped', default_class=None, allow_multiple_classes=True) ...

Loads the CSV file, returning a list of dictionaries with types coerced.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.ConnectionURIOpener.html0000644000175000017500000001203512754657337027043 0ustar phdphd00000000000000

ConnectionURIOpener

The ConnectionURIOpener class is accessible via the sqlobject.dbconnection module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self) ...

f registerConnection(self, schemes, builder) ...

f registerConnectionInstance(self, inst) ...

f connectionForURI(self, uri, oldUri=False, **args) ...

f dbConnectionForScheme(self, scheme) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlite.sqliteconnection.SQLiteConnection.html0000644000175000017500000003171612754657337030617 0ustar phdphd00000000000000

SQLiteConnection

The SQLiteConnection class is accessible via the sqlobject.sqlite.sqliteconnection module.

Attributes

a supportTransactions

True

a schemes

['sqlite']

a dbName

'sqlite'

Methods

f __init__(self, filename, autoCommit=1, **kw) ...

f oldUri(self) ...

f uri(self) ...

f getConnection(self) ...

f releaseConnection(self, conn, explicit=False) ...

f makeMemoryConnection(self) ...

f makeConnection(self) ...

f close(self) ...

f createColumn(self, soClass, col) ...

f createReferenceConstraint(self, soClass, col) ...

f createIDColumn(self, soClass) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f createIndexSQL(self, soClass, index) ...

f addColumn(self, tableName, column) ...

f delColumn(self, sqlmeta, column) ...

f recreateTableWithoutColumn(self, sqlmeta, column) ...

f columnsFromSchema(self, tableName, soClass) ...

f guessClass(self, t) ...

f listTables(self) ...

f listDatabases(self) ...

f createEmptyDatabase(self) ...

f dropDatabase(self) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.versioning-index.html0000644000175000017500000001457212754657322024221 0ustar phdphd00000000000000 Index of sqlobject.versioning module

Index of the versioning module

SQLObject-3.1.0/docs/html/class-sqlobject.classregistry.ClassRegistry.html0000644000175000017500000001515112754657334026241 0ustar phdphd00000000000000

ClassRegistry

We'll be dealing with classes that reference each other, so class C1 may reference C2 (in a join), while C2 references C1 right back. Since classes are created in an order, there will be a point when C1 exists but C2 doesn't. So we deal with classes by name, and after each class is created we try to fix up any references by replacing the names with actual classes.

The ClassRegistry class is accessible via the sqlobject.classregistry module.

Here we keep a dictionaries of class names to classes -- note that the classes might be spread among different modules, so since we pile them together names need to be globally unique, to just module unique. Like needSet below, the container dictionary is keyed by the class registry.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name) ...

f addClassCallback(self, className, callback, *args, **kw) ...

Whenever a name is substituted for the class, you can register a callback that will be called when the needed class is created. If it's already been created, the callback will be called immediately.

f addCallback(self, callback, *args, **kw) ...

This callback is called for all classes, not just specific ones (like addClassCallback).

f addClass(self, cls) ...

Everytime a class is created, we add it to the registry, so that other classes can find it by name. We also call any callbacks that are waiting for the class.

f getClass(self, className) ...

f allClasses(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.DecimalStringCol.html0000644000175000017500000000761212754657351024507 0ustar phdphd00000000000000

DecimalStringCol

The DecimalStringCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.include.hashcol-index.html0000644000175000017500000001124612754657317025100 0ustar phdphd00000000000000 Index of sqlobject.include.hashcol module

Index of the hashcol module

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.DatabaseError.html0000644000175000017500000001332212754657323025101 0ustar phdphd00000000000000

DatabaseError

The DatabaseError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mssql.mssqlconnection-index.html0000644000175000017500000002245512754657324026414 0ustar phdphd00000000000000 Index of sqlobject.mssql.mssqlconnection module

Index of the mssqlconnection module

SQLObject-3.1.0/docs/html/class-sqlobject.views.ViewSQLObjectTable.html0000644000175000017500000003322112754657321025265 0ustar phdphd00000000000000

ViewSQLObjectTable

The ViewSQLObjectTable class is accessible via the sqlobject.views module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f __sqlrepr__(self, db) ...

f __init__(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/layout.css0000711000175000017500000000373312754657230016610 0ustar phdphd00000000000000@import url("pudge.css"); @import url("site.css"); /* Basic Style ----------------------------------- */ h1.pudge-member-page-heading { } h4.pudge-member-page-subheading { font-size: medium; margin-top: -1.0em; margin-left: 2em; margin-bottom: .3em; } p.pudge-member-blurb { /* font-weight: bold; */ font-size: 120%; margin-top: 0.2em; } p.pudge-member-parent-link { margin-top: 0; } /*div.pudge-module-doc { max-width: 45em; }*/ div.pudge-section { margin-left: 2em; max-width: 45em; } /* Section Navigation ----------------------------------- */ div#pudge-section-nav { margin: 1em 0 1.5em 0; padding: 0; height: 20px; } div#pudge-section-nav ul { border: 0; margin: 0; padding: 0; list-style-type: none; text-align: center; border-right: 1px solid #aaa; } div#pudge-section-nav ul li { display: block; float: left; text-align: center; padding: 0; margin: 0; } div#pudge-section-nav ul li .pudge-section-link, div#pudge-section-nav ul li .pudge-missing-section-link { background: #aaa; width: 9em; height: 1.8em; border: 1px solid #bbb; padding: 0; margin: 0 0 10px 0; color: #ddd; text-decoration: none; display: block; text-align: center; font: 11px/20px "Verdana", "Lucida Grande"; cursor: hand; text-transform: lowercase; } div#pudge-section-nav ul li a:hover { color: #000; background: #fff; } div#pudge-section-nav ul li .pudge-section-link { background: #888; color: #eee; border: 1px solid #bbb; } /* Module Lists ----------------------------------- */ dl.pudge-module-list dt { font-style: normal; font-size: 110%; } dl.pudge-module-list dd { /*color: #555;*/ } /* Misc Overrides */ .rst-doc p.topic-title a { color: #777; } .rst-doc ul.auto-toc a, .rst-doc div.contents a { color: #333; } pre { background: #eee; } .rst-doc dl dt { color: #444; margin-top: 1em; font-weight: bold; } .rst-doc dl dd { margin-top: .2em; } .rst-doc hr { display: block; margin: 2em 0; }SQLObject-3.1.0/docs/html/module-sqlobject.converters-index.html0000644000175000017500000002341112754657334024223 0ustar phdphd00000000000000 Index of sqlobject.converters module

Index of the converters module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.OuterField.html0000644000175000017500000004133512754657330024754 0ustar phdphd00000000000000

OuterField

The OuterField class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

f __init__(self, tableName, fieldName, original, soClass, column) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsedImmediate(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.NoDefault.html0000644000175000017500000000172512754657330024572 0ustar phdphd00000000000000

NoDefault

The NoDefault class is accessible via the sqlobject.sqlbuilder module.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.firebird.firebirdconnection-index.html0000644000175000017500000002235612754657333027472 0ustar phdphd00000000000000 Index of sqlobject.firebird.firebirdconnection module

Index of the firebirdconnection module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLPrefix.html0000644000175000017500000004120712754657332024527 0ustar phdphd00000000000000

SQLPrefix

The SQLPrefix class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, prefix, expr) ...

f __sqlrepr__(self, db) ...

f components(self) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mysql.mysqlconnection-index.html0000644000175000017500000002247612754657315026433 0ustar phdphd00000000000000 Index of sqlobject.mysql.mysqlconnection module

Index of the mysqlconnection module

SQLObject-3.1.0/docs/html/module-sqlobject-index.html0000644000175000017500000146011512754657240022035 0ustar phdphd00000000000000 Index of sqlobject module

Index of the sqlobject module

SQLObject-3.1.0/docs/html/module-sqlobject.maxdb.html0000644000175000017500000000522612754657342022022 0ustar phdphd00000000000000

maxdb

The maxdb module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.maxdb'

Functions

f builder() ...

Modules

The sqlobject.maxdb module exposes 1 submodules:

maxdbconnection
Contributed by Edigram SAS, Paris France Tel:01 44 77 94 00 Ahmed MOHAMED ALI <ahmedmoali@yahoo.com> 27 April 2004

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sresults.SelectResults.html0000644000175000017500000003357412754657344025244 0ustar phdphd00000000000000

SelectResults

The SelectResults class is accessible via the sqlobject.sresults module.

Attributes

a throughTo

<property object at 0xb65cfe14>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, sourceClass, clause, clauseTables=None, **ops) ...

f queryForSelect(self) ...

f clone(self, **newOps) ...

f orderBy(self, orderBy) ...

f connection(self, conn) ...

f limit(self, limit) ...

f lazyColumns(self, value) ...

f reversed(self) ...

f distinct(self) ...

f newClause(self, new_clause) ...

f filter(self, filter_clause) ...

f __getitem__(self, value) ...

f __iter__(self) ...

f lazyIter(self) ...

Returns an iterator that will lazily pull rows out of the database and return SQLObject instances

f accumulate(self, *expressions) ...

Use accumulate expression(s) to select result using another SQL select through current connection. Return the accumulate result

f count(self) ...

Counting elements of current select results

f accumulateMany(self, *attributes) ...

Making the expressions for count/sum/min/max/avg of a given select result attributes. attributes must be a list/tuple of pairs (func_name, attribute); attribute can be a column name (like 'a_column') or a dot-q attribute (like Table.q.aColumn)

f accumulateOne(self, func_name, attribute) ...

Making the sum/min/max/avg of a given select result attribute. attribute can be a column name (like 'a_column') or a dot-q attribute (like Table.q.aColumn)

f sum(self, attribute) ...

f min(self, attribute) ...

f avg(self, attribute) ...

f max(self, attribute) ...

f getOne(self, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>) ...

If a query is expected to only return a single value, using .getOne() will return just that value.

If not results are found, SQLObjectNotFound will be raised, unless you pass in a default value (like .getOne(None)).

If more than one result is returned, SQLObjectIntegrityError will be raised.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.EnumCol.html0000644000175000017500000000750212754657352022665 0ustar phdphd00000000000000

EnumCol

The EnumCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.DecimalCol.html0000644000175000017500000000753212754657350023320 0ustar phdphd00000000000000

DecimalCol

The DecimalCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.RowDestroyedSignal.html0000644000175000017500000000712212754657341025636 0ustar phdphd00000000000000

RowDestroyedSignal

Called after an instance is deleted. Sender is the instance's class. Arguments are (instance).

The RowDestroyedSignal class is accessible via the sqlobject.events module.

This is called before the post_funcs of RowDestroySignal

Note: this is not called when an instance is destroyed through garbage collection.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLCall.html0000644000175000017500000004106312754657327024151 0ustar phdphd00000000000000

SQLCall

The SQLCall class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, expr, args) ...

f __sqlrepr__(self, db) ...

f components(self) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/TODO.html0000644000175000017500000001673312754657232016227 0ustar phdphd00000000000000 TODO

TODO

  • RelatedJoin.hasOther(otherObject[.id])

  • createParamsPre/Post:

    class MyTable(SQLObject):
    class sqlmeta:
        createParamsPre = 'TEMPORARY IF NOT EXISTS'
        createParamsPre = {temporary: True, ifNotExists: True,
                           'postgres': 'LOCAL'}
        createParamsPost = 'ENGINE InnoDB'
        createParamsPost = {'mysql': 'ENGINE InnoDB',
                            'postgres': 'WITH OIDS'}

  • SQLObject.fastInsert().

  • IntervalCol

  • TimedeltaCol

  • Cached join results.

  • Invert tests isinstance(obj, (tuple, list)) to not isinstance(obj, basestr) to allow any iterable.

  • Always use .lazyIter().

  • Optimize Iteration.next() - use cursor.fetchmany().

  • Generators instead of loops (fetchall => fetchone).

  • Cache columns in sqlmeta.getColumns(); reset the cache on add/del Column/Join.

  • Make ConnectionHub a context manager instead of .doInTransaction().

  • Make version_info a namedtuple.

  • Expression columns - in SELECT but not in INSERT/UPDATE. Something like this:

    class MyClass(SQLObject):
    function1 = ExpressionCol(func.my_function(MyClass.q.col1))
    function2 = ExpressionCol('sum(col2)')

  • A hierarchy of exceptions. SQLObject should translate exceptions from low-level drivers to a consistent set of high-level exceptions.

  • Memcache.

  • Refactor DBConnection to use parameterized queries instead of generating query strings.

  • PREPARE/EXECUTE.

  • Protect all .encode(), catch UnicodeEncode exceptions and reraise Invalid.

  • More kinds of joins, and more powerful join results (closer to how select works).

  • Better joins - automatic joins in .select() based on ForeignKey/MultipleJoin/RelatedJoin.

  • Deprecate, then remove connectionForOldURI.

  • Switch from setuptools to distribute.

  • oursql MySQL bindings: https://github.com/python-oursql/oursql

  • MySQL Connector/Python: https://dev.mysql.com/doc/connector-python/en/

  • Pure Python Mysql Interface: https://github.com/nasi/MyPy

  • pg8000 driver: http://code.google.com/p/pg8000/

  • py-postgresql driver: http://python.projects.postgresql.org/

  • pyfirebirdsql: https://github.com/nakagami/pyfirebirdsql

  • dict API: use getitem interface for column access instead of getattr; reserve getattr for internal attributes only; this helps to avoid collisions with internal attributes.

  • Or move column values access to a separate namespace, e.g. .c: row.c.column.

  • More documentation.

  • RSS 2.0 and Atom news feeds.

  • Use DBUtils, especially SolidConnection.

  • _fromDatabase currently doesn't support IDs that don't fit into the normal naming scheme. It should do so. You can still use _idName with _fromDatabase.
  • More databases supported. There has been interest and some work in the progress for Oracle. IWBN to have Informix and DB2 drivers.
  • Better transaction support -- right now you can use transactions for the database, but objects aren't transaction-aware, so non-database persistence won't be able to be rolled back.
  • Optimistic locking and other techniques to handle concurrency.
  • Profile of SQLObject performance to identify bottlenecks.
  • Increase hooks with FormEncode validation and form generation package, so SQLObject classes (read: schemas) can be published for editing more directly and easily. (First step: get Schema-generating method into sqlmeta class)
  • Merge SQLObject.create*, .create*SQL methods with DBPI.create* methods.
  • Made SQLObject unicode-based instead of just unicode-aware. All internal processing should be done with unicode strings, conversion to/from ascii strings should happen for non-unicode DB API drivers.
  • Allow to override ConsoleWriter/LogWriter classes and makeDebugWriter function.
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.include.tests-index.html0000644000175000017500000001473512754657317024627 0ustar phdphd00000000000000 Index of sqlobject.include.tests module

Index of the tests module

SQLObject-3.1.0/docs/html/News3.html0000644000175000017500000004436612754657232016464 0ustar phdphd00000000000000 News

News

SQLObject 0.10.9

  • The cache culling algorithm was enhanced to eliminate memory leaks by removing references to dead objects; tested on a website that runs around 4 million requests a day.

SQLObject 0.10.8

Released 30 Sep 2009.

  • Fixed a bug in logging to console - convert unicode to str.
  • Fixed an obscure bug in ConnectionHub triggered by an SQLObject class whose instances can be coerced to boolean False.

SQLObject 0.10.7

Released 20 Sep 2009.

  • Fixed a bug: Sybase tables with identity column fire two identity_inserts.
  • Fixed a bug: q.startswith(), q.contains() and q.endswith() escape (with a backslash) all special characters (backslashes, underscores and percent signs).

SQLObject 0.10.6

Released 18 May 2009.

  • Better support for Python 2.6: do not import the deprecated sets module.
  • A number of changes ported from SQLObject 0.9.11.

SQLObject 0.10.5

Released 6 May 2009.

  • A number of changes ported from SQLObject 0.9.10.
  • sqlmeta.getColumns() becomes classmethod.

SQLObject 0.10.4

Released 8 Dec 2008.

  • Fixed createSQL constrains generation under MySQL when the table's name includes the database's name (contains a dot).

SQLObject 0.10.3

Released 1 Dec 2008.

SQLObject 0.10.2

Released 30 May 2008.

SQLObject 0.10.1

Released 4 May 2008.

  • Fixed a bug: limit doesn't work in sqlbuilder.Select.
  • A number of changes ported from SQLObject 0.9.6.

SQLObject 0.10.0

Released 11 Mar 2008.

Features & Interface

  • Dropped support for Python 2.2. The minimal version of Python for SQLObject is 2.3 now.
  • Removed actively deprecated attributes; lowered deprecation level for other attributes to be removed after 0.10.
  • SQLBuilder Select supports the rest of SelectResults options (reversed, distinct, joins, etc.)
  • SQLObject.select() (i.e., SelectResults) and DBConnection.queryForSelect() use SQLBuilder Select queries; this make all SELECTs implemented internally via a single mechanism.
  • SQLBuilder Joins handle SQLExpression tables (not just str/SQLObject/Alias) and properly sqlrepr.
  • Added SQLBuilder ImportProxy. It allows one to ignore the circular import issues with referring to SQLObject classes in other files - it uses the classregistry as the string class names for FK/Joins do, but specifically intended for SQLBuilder expressions. See tests/test_sqlbuilder_importproxy.py.
  • Added SelectResults.throughTo. It allows one to traverse relationships (FK/Join) via SQL, avoiding the intermediate objects. Additionally, it's a simple mechanism for pre-caching/eager-loading of later FK relationships (i.e., going to loop over a select of somePeople and ask for aPerson.group, first call list(somePeople.throughTo.group) to preload those related groups and use 2 db queries instead of N+1). See tests/test_select_through.py.
  • Added ViewSQLObject.
  • Added sqlmeta.getColumns() to get all the columns for a class (including parent classes), excluding the column 'childName' and including the column 'id'. sqlmeta.asDict() now uses getColumns(), so there is no need to override it in the inheritable sqlmeta class; this makes asDict() to work properly on inheritable sqlobjects.
  • Allow MyTable.select(MyTable.q.foreignKey == object) where object is an instance of SQLObject.
  • Added rich comparison methods; SQLObjects of the same class are considered equal is they have the same id; other methods return NotImplemented.
  • RowDestroySignal is sent on destroying an SQLObject instance; postfunctions are run after the row has been destroyed.
  • Changed the implementation type in BoolCol under SQLite from TINYINT to BOOLEAN and made fromDatabase machinery to recognize it.
  • MySQLConnection (and DB URI) accept a number of SSL-related parameters: ssl_key, ssl_cert, ssl_ca, ssl_capath.
  • Use sets instead of dicts in tablesUsed. Dropped tablesUsedDict function; instead there is tablesUsedSet that returns a set of strings.
  • SQLBuilder tablesUsedSet handles sqlrepr'able objects.
  • Under MySQL, PickleCol no longer used TEXT column types; the smallest column is now BLOB - it is not possible to create TINYBLOB column.

SQLObject 0.9.11

Released 18 May 2009.

  • Two bugs in SQLiteConnection.columnsFromSchema() were fixed: use sqlmeta.idName instead of 'id'; convert default 'NULL' to None.
  • Use sqlmeta.idName instead of 'id' in all connection classes.
  • Fixed a bug that prevented to override per class _connection if there is sqlhub.processConnection.

SQLObject 0.9.10

Released 6 May 2009.

  • Another unicode-related patch for MySQL; required because different versions of MySQLdb require different handling:

    - MySQLdb < 1.2.1: only ascii
- MySQLdb = 1.2.1: only unicode
- MySQLdb > 1.2.1: both ascii and unicode

  • Setup requires FormEncode version 1.1.1+.

  • A minor bug was fixed in creating a DecimalValidator - pass the column name to it.

  • A bug was fixed in InheritableIteration - pass connection to child klass.select().

  • A bug was fixed in PostgresConnection.columnsFromSchema() - foreign keys are now recognized and created as proper ForeignKey with correct column name and table name.

  • Bugs in PostgresConnection and MSSQLConnection related to properties was fixed. A note for developers: from now on properties in DBConnection classes are forbidden as they don't work with Transaction - Transaction.__getattr__() cannot properly wrap 'self' so a property is called with wrong 'self'.

  • Transaction instances now explicitly raises TypeError on close() - without this calling Transaction.close() calls connection.close() which is wrong.

  • A bug in SQLiteConnection.columnsFromSchema() that led to an infinite loop was fixed.

SQLObject 0.9.9

  • Backported from the trunk: under MySQL use the connection's dbEncoding instead of ascii, when converting a unicode value from python to database for a StringCol.

SQLObject 0.9.8

Released 1 Dec 2008.

  • Changed interpretation of strings in the DB URI for boolean parameters: '0', 'no', 'off' and 'false' are now interpreted as False.
  • Fixed a bug with incorrect handling of calls like connectionForURI(dburi, cache=False) when dburi already contains some parameters in the URI.
  • Convert decimal.to_eng_string() to str to work around a bug in Python 2.5.2; see https://mail.python.org/pipermail/python-dev/2008-March/078189.html
  • Added test_default_style.py.
  • Fixed a minor bug in SQLiteConnection that fails to parse Enum columns.

SQLObject 0.9.7

Released 30 May 2008.

Small Features

  • Use VARCHAR(MAX) and VARBINARY(MAX) for MSSQL >= 9.0.
  • Run post_funcs after RowDestroySignal.

Bug Fixes

  • Fixed a minor bug in Set column.
  • A bug fixed for RowCreatedSignal together with InheritableSQLObject: run post_funcs after the entire hierarchy has been created.
  • Aggregate functions now honors 'distinct'.

SQLObject 0.9.6

Released 4 May 2008.

  • A bug in inheritable delColumn() that doesn't remove properties was fixed.
  • A minor bug was fixed in col.py - the registry must be passed to findClass().
  • Reverted the patch declarative.threadSafeMethod() - it causes more harm then good.

SQLObject 0.9.5

Released 10 Mar 2008.

  • Fixed a minor bug in SQLiteConnection.columnsFromSchema() - set dbName.
  • A bug in delColumn() that removes all properties was fixed by recreating properties.

SQLObject 0.9.4

Released 3 Mar 2008.

  • Use list.reverse() in manager/command.py for Python 2.2 compatibility.
  • Prevent MultipleJoin from removing the intermediate table if it was not created by the Join.
  • Fixed a bug with no default when defaultSQL is defined for the column.
  • Recognize POINT data type as string in PostgresConnection.columnsFromSchema().

SQLObject 0.9.3

Released 10 Jan 2008.

  • A number of changes ported from SQLObject 0.7.10.

SQLObject 0.9.2

Released 30 Oct 2007.

  • Fixed a bug in Versioning - do not copy "alternateID" and "unique" attributes from the versioned table.
  • Fixed a misspelled 'zerofill' option's name.
  • Fixed bugs in SQLiteConnection.guessColumn().
  • A number of changes ported from SQLObject 0.7.9 and SQLObject 0.8.6.

SQLObject 0.9.1

Released 25 July 2007.

Bug Fixes

  • Fixed misspelled methods in col.py.
  • A number of bugfixes ported from SQLObject 0.7.8 and SQLObject 0.8.5.

SQLObject 0.9.0

Released 10 May 2007.

Features & Interface

  • Support for Python 2.2 has been declared obsolete.
  • Removed actively deprecated attributes; lowered deprecation level for other attributes to be removed after 0.9.
  • SQLite connection got columnsFromSchema(). Now all connections fully support fromDatabase. There are two version of columnsFromSchema() for SQLite - one parses the result of "SELECT sql FROM sqlite_master" and the other uses "PRAGMA table_info"; the user can choose one over the other by using "use_table_info" parameter in DB URI; default is False as the pragma is available only in the later versions of SQLite.
  • Changed connection.delColumn(): the first argument is sqlmeta, not tableName (required for SQLite).
  • SQLite connection got delColumn(). Now all connections fully support delColumn(). As SQLite backend doesn't implement "ALTER TABLE DROP COLUMN" delColumn() is implemented by creating a new table without the column, copying all data, dropping the original table and renaming the new table.
  • Versioning.
  • MySQLConnection got new keyword "conv" - a list of custom converters.
  • Use logging if it's available and is configured via DB URI.
  • New columns: TimestampCol to support MySQL TIMESTAMP type; SetCol to support MySQL SET type; TinyIntCol for TINYINT; SmallIntCol for SMALLINT; MediumIntCol for MEDIUMINT; BigIntCol for BIGINT.

Small Features

  • Support for MySQL INT type attributes: UNSIGNED, ZEROFILL.
  • Support for DEFAULT SQL attribute via defaultSQL keyword argument.
  • cls.tableExists() as a shortcut for conn.tableExists(cls.sqlmeta.table).
  • cls.deleteMany(), cls.deleteBy().

Bug Fixes

  • idName can be inherited from the parent sqlmeta class.

Older news

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.declarative.classinstancemethod.html0000644000175000017500000000754712754657343027075 0ustar phdphd00000000000000

classinstancemethod

Acts like a class method when called from a class, like an instance method when called by an instance. The method should take two arguments, 'self' and 'cls'; one of these will be None depending on how the method was called.

The classinstancemethod class is accessible via the sqlobject.declarative module.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, func) ...

f __get__(self, obj, type=None) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.classregistry-index.html0000644000175000017500000001403612754657334024732 0ustar phdphd00000000000000 Index of sqlobject.classregistry module

Index of the classregistry module

  • m sqlobject.classregistry ... -
    classresolver.py
    2 February 2004, Ian Bicking <ianb@colorstudy.com>
    • a __package__ ...
    • a MasterRegistry ...
    • C ClassRegistry ... - We'll be dealing with classes that reference each other, so class C1 may reference C2 (in a join), while C2 references C1 right back. Since classes are created in an order, there will be a point when C1 exists but C2 doesn't. So we deal with classes by name, and after each class is created we try to fix up any references by replacing the names with actual classes.
      • f addClassCallback ... - Whenever a name is substituted for the class, you can register a callback that will be called when the needed class is created. If it's already been created, the callback will be called immediately.
      • f getClass ...
      • f allClasses ...
      • f addCallback ... - This callback is called for all classes, not just specific ones (like addClassCallback).
      • f __init__ ...
      • f addClass ... - Everytime a class is created, we add it to the registry, so that other classes can find it by name. We also call any callbacks that are waiting for the class.
    • f registry ...
    • f findClass ...
SQLObject-3.1.0/docs/html/class-sqlobject.col.SOMediumIntCol.html0000644000175000017500000002436512754657347024130 0ustar phdphd00000000000000

SOMediumIntCol

The SOMediumIntCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

f addSQLAttrs(self, str) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.main.html0000644000175000017500000001503612754657334021654 0ustar phdphd00000000000000

main

The main module is accessible via the sqlobject module.

SQLObject is a object-relational mapper. See SQLObject.html or SQLObject.rst for more.

With the help by Oleg Broytman and many other contributors. See Authors.rst.

This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.

Attributes

a __package__

'sqlobject'

a sqlhub

<sqlobject.dbconnection.ConnectionHub object at 0xb65baaac>

Functions

f getID(obj, refColumn=None) ...

f getObject(obj, klass) ...

Classes

C SQLObjectNotFound(...) ...

This class contains 10 members.

C SQLObjectIntegrityError(...) ...

This class contains 10 members.

C NoDefault(...) ...

C sqlmeta(...) ...

This object is the object we use to keep track of all sorts of information. Subclasses are made for each SQLObject subclass (dynamically if necessary), and instances are created to go alongside every SQLObject instance.

This class contains 38 members.

C SQLObject(...) ...

This class contains 41 members.

See the source for more information.

SQLObject-3.1.0/docs/html/SQLObject.html0000644000175000017500000033374312754657232017253 0ustar phdphd00000000000000 SQLObject

SQLObject

Credits

SQLObject is by Ian Bicking (ianb@colorstudy.com) and Contributors. The website is sqlobject.org.

License

The code is licensed under the Lesser General Public License (LGPL).

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

Introduction

SQLObject is an object-relational mapper for Python programming language. It allows you to translate RDBMS table rows into Python objects, and manipulate those objects to transparently manipulate the database.

In using SQLObject, you will create a class definition that will describe how the object translates to the database table. SQLObject will produce the code to access the database, and update the database with your changes. The generated interface looks similar to any other interface, and callers need not be aware of the database backend.

SQLObject also includes a novel feature to avoid generating, textually, your SQL queries. This also allows non-SQL databases to be used with the same query syntax.

Requirements

Currently SQLObject supports MySQL via MySQLdb aka MySQL-python, PostgreSQL via psycopg2 or psycopg1, SQLite via PySQLite, Firebird via fdb or kinterbasdb, MAX DB (also known as SAP DB) via sapdb, Sybase via Sybase, and MSSQL Server via pymssql (+ FreeTDS) or adodbapi (Win32).

Python 2.6, 2.7 or 3.4+ is required.

Compared To Other Database Wrappers

There are several object-relational mappers (ORM) for Python. I honestly can't comment deeply on the quality of those packages, but I'll try to place SQLObject in perspective.

SQLObject uses new-style classes extensively. The resultant objects have a new-style feel as a result -- setting attributes has side effects (it changes the database), and defining classes has side effects (through the use of metaclasses). Attributes are generally exposed, not marked private, knowing that they can be made dynamic or write-only later.

SQLObject creates objects that feel similar to normal Python objects (with the semantics of new-style classes). An attribute attached to a column doesn't look different than an attribute that's attached to a file, or an attribute that is calculated. It is a specific goal that you be able to change the database without changing the interface, including changing the scope of the database, making it more or less prominent as a storage mechanism.

This is in contrast to some ORMs that provide a dictionary-like interface to the database (for example, PyDO). The dictionary interface distinguishes the row from a normal Python object. I also don't care for the use of strings where an attribute seems more natural -- columns are limited in number and predefined, just like attributes. (Note: newer version of PyDO apparently allow attribute access as well)

SQLObject is, to my knowledge, unique in using metaclasses to facilitate this seamless integration. Some other ORMs use code generation to create an interface, expressing the schema in a CSV or XML file (for example, MiddleKit, part of Webware). By using metaclasses you are able to comfortably define your schema in the Python source code. No code generation, no weird tools, no compilation step.

SQLObject provides a strong database abstraction, allowing cross-database compatibility (so long as you don't sidestep SQLObject).

SQLObject has joins, one-to-many, and many-to-many, something which many ORMs do not have. The join system is also intended to be extensible.

You can map between database names and Python attribute and class names; often these two won't match, or the database style would be inappropriate for a Python attribute. This way your database schema does not have to be designed with SQLObject in mind, and the resulting classes do not have to inherit the database's naming schemes.

Using SQLObject: An Introduction

Let's start off quickly. We'll generally just import everything from the sqlobject class:

>>> from sqlobject import *
>>> import sys, os

Declaring a Connection

The connection URI must follow the standard URI syntax:

scheme://[user[:password]@]host[:port]/database[?parameters]

Scheme is one of sqlite, mysql, postgres, firebird, interbase, maxdb, sapdb, mssql, sybase.

Examples:

mysql://user:password@host/database
mysql://host/database?debug=1
postgres://user@host/database?debug=&cache=
postgres:///full/path/to/socket/database
postgres://host:5432/database
sqlite:///full/path/to/database
sqlite:/C:/full/path/to/database
sqlite:/:memory:

Parameters are: debug (default: False), debugOutput (default: False), cache (default: True), autoCommit (default: True), debugThreading (default: False), logger (default: None), loglevel (default: None), schema (default: None).

If you want to pass True value in a connection URI - pass any non-empty string; an empty string for False.

Lets first set up a connection:

>>> db_filename = os.path.abspath('data.db')
>>> if os.path.exists(db_filename):
...     os.unlink(db_filename)
>>> connection_string = 'sqlite:' + db_filename
>>> connection = connectionForURI(connection_string)
>>> sqlhub.processConnection = connection

The sqlhub.processConnection assignment means that all classes will, by default, use this connection we've just set up.

Declaring the Class

We'll develop a simple addressbook-like database. We could create the tables ourselves, and just have SQLObject access those tables, but let's have SQLObject do that work. First, the class:

>>> class Person(SQLObject):
...
...     firstName = StringCol()
...     middleInitial = StringCol(length=1, default=None)
...     lastName = StringCol()

Many basic table schemas won't be any more complicated than that. firstName, middleInitial, and lastName are all columns in the database. The general schema implied by this class definition is:

CREATE TABLE person (
    id INT PRIMARY KEY AUTO_INCREMENT,
    first_name TEXT,
    middle_initial CHAR(1),
    last_name TEXT
);

This is for SQLite or MySQL. The schema for other databases looks slightly different (especially the id column). You'll notice the names were changed from mixedCase to underscore_separated -- this is done by the style object. There are a variety of ways to handle names that don't fit conventions (see Irregular Naming).

Now we'll create the table in the database:

>>> Person.createTable()
[]

We can change the type of the various columns by using something other than StringCol, or using different arguments. More about this in Column Types.

You'll note that the id column is not given in the class definition, it is implied. For MySQL databases it should be defined as INT PRIMARY KEY AUTO_INCREMENT, in Postgres SERIAL PRIMARY KEY, and in SQLite as INTEGER PRIMARY KEY. You can't use tables with SQLObject that don't have a single primary key, and you must treat that key as immutable (otherwise you'll confuse SQLObject terribly).

You can override the id name in the database, but it is always called .id from Python.

Using the Class

Now that you have a class, how will you use it? We'll be considering the class defined above.

To create a new object (and row), use class instantiation, like:

>>> Person(firstName="John", lastName="Doe")
<Person 1 firstName='John' middleInitial=None lastName='Doe'>

Note

In SQLObject NULL/None does not mean default. NULL is a funny thing; it mean very different things in different contexts and to different people. Sometimes it means "default", sometimes "not applicable", sometimes "unknown". If you want a default, NULL or otherwise, you always have to be explicit in your class definition.

Also note that the SQLObject default isn't the same as the database's default (SQLObject never uses the database's default).

If you had left out firstName or lastName you would have gotten an error, as no default was given for these columns (middleInitial has a default, so it will be set to NULL, the database equivalent of None).

You can use the class method .get() to fetch instances that already exist:

>>> Person.get(1)
<Person 1 firstName='John' middleInitial=None lastName='Doe'>

When you create an object, it is immediately inserted into the database. SQLObject uses the database as immediate storage, unlike some other systems where you explicitly save objects into a database.

Here's a longer example of using the class:

>>> p = Person.get(1)
>>> p
<Person 1 firstName='John' middleInitial=None lastName='Doe'>
>>> p.firstName
'John'
>>> p.middleInitial = 'Q'
>>> p.middleInitial
'Q'
>>> p2 = Person.get(1)
>>> p2
<Person 1 firstName='John' middleInitial='Q' lastName='Doe'>
>>> p is p2
True

Columns are accessed like attributes. (This uses the property feature of Python, so that retrieving and setting these attributes executes code). Also note that objects are unique -- there is generally only one Person instance of a particular id in memory at any one time. If you ask for a person by a particular ID more than once, you'll get back the same instance. This way you can be sure of a certain amount of consistency if you have multiple threads accessing the same data (though of course across processes there can be no sharing of an instance). This isn't true if you're using transactions, which are necessarily isolated.

To get an idea of what's happening behind the surface, I'll give the same actions with the SQL that is sent, along with some commentary:

>>> # This will make SQLObject print out the SQL it executes:
>>> Person._connection.debug = True
>>> p = Person(firstName='Bob', lastName='Hope')
 1/QueryIns:  INSERT INTO person (first_name, middle_initial, last_name) VALUES ('Bob', NULL, 'Hope')
 1/QueryR  :  INSERT INTO person (first_name, middle_initial, last_name) VALUES ('Bob', NULL, 'Hope')
 1/COMMIT  :  auto
 1/QueryOne:  SELECT first_name, middle_initial, last_name FROM person WHERE ((person.id) = (2))
 1/QueryR  :  SELECT first_name, middle_initial, last_name FROM person WHERE ((person.id) = (2))
 1/COMMIT  :  auto
>>> p
<Person 2 firstName='Bob' middleInitial=None lastName='Hope'>
>>> p.middleInitial = 'Q'
 1/Query   :  UPDATE person SET middle_initial = ('Q') WHERE id = (2)
 1/QueryR  :  UPDATE person SET middle_initial = ('Q') WHERE id = (2)
 1/COMMIT  :  auto
>>> p2 = Person.get(1)
>>> # Note: no database access, since we're just grabbing the same
>>> # instance we already had.

Hopefully you see that the SQL that gets sent is pretty clear and predictable. To view the SQL being sent, add ?debug=t to your connection URI, or set the debug attribute on the connection, and all SQL will be printed to the console. This can be reassuring, and I would encourage you to try it.

As a small optimization, instead of assigning each attribute individually, you can assign a number of them using the set method, like:

>>> p.set(firstName='Robert', lastName='Hope Jr.')

This will send only one UPDATE statement. You can also use set with non-database properties (there's no benefit, but it helps hide the difference between database and non-database attributes).

Selecting Multiple Objects

While the full power of all the kinds of joins you can do with a relational database are not revealed in SQLObject, a simple SELECT is available.

select is a class method, and you call it like (with the SQL that's generated):

>>> Person._connection.debug = True
>>> peeps = Person.select(Person.q.firstName=="John")
>>> list(peeps)
 1/Select  :  SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE ((person.first_name) = ('John'))
 1/QueryR  :  SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE ((person.first_name) = ('John'))
 1/COMMIT  :  auto
[<Person 1 firstName='John' middleInitial='Q' lastName='Doe'>]

This example returns everyone with the first name John.

Queries can be more complex:

>>> peeps = Person.select(
...         OR(Person.q.firstName == "John",
...            LIKE(Person.q.lastName, "%Hope%")))
>>> list(peeps)
 1/Select  :  SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE (((person.first_name) = ('John')) OR (person.last_name LIKE ('%Hope%')))
 1/QueryR  :  SELECT person.id, person.first_name, person.middle_initial, person.last_name FROM person WHERE (((person.first_name) = ('John')) OR (person.last_name LIKE ('%Hope%')))
 1/COMMIT  :  auto
[<Person 1 firstName='John' middleInitial='Q' lastName='Doe'>, <Person 2 firstName='Robert' middleInitial='Q' lastName='Hope Jr.'>]

You'll note that classes have an attribute q, which gives access to special objects for constructing query clauses. All attributes under q refer to column names and if you construct logical statements with these it'll give you the SQL for that statement. You can also create your SQL more manually:

>>> Person._connection.debug = False  # Need for doctests
>>> peeps = Person.select("""person.first_name = 'John' AND
...                          person.last_name LIKE 'D%'""")

You should use MyClass.sqlrepr to quote any values you use if you create SQL manually (quoting is automatic if you use q).

You can use the keyword arguments orderBy to create ORDER BY in the select statements: orderBy takes a string, which should be the database name of the column, or a column in the form Person.q.firstName. You can use "-colname" or DESC(Person.q.firstName) to specify descending order (this is translated to DESC, so it works on non-numeric types as well), or call MyClass.select().reversed(). orderBy can also take a list of columns in the same format: ["-weight", "name"].

You can use the sqlmeta class variable defaultOrder to give a default ordering for all selects. To get an unordered result when defaultOrder is used, use orderBy=None.

Select results are generators, which are lazily evaluated. So the SQL is only executed when you iterate over the select results, or if you use list() to force the result to be executed. When you iterate over the select results, rows are fetched one at a time. This way you can iterate over large results without keeping the entire result set in memory. You can also do things like .reversed() without fetching and reversing the entire result -- instead, SQLObject can change the SQL that is sent so you get equivalent results.

You can also slice select results. This modifies the SQL query, so peeps[:10] will result in LIMIT 10 being added to the end of the SQL query. If the slice cannot be performed in the SQL (e.g., peeps[:-10]), then the select is executed, and the slice is performed on the list of results. This will generally only happen when you use negative indexes.

In certain cases, you may get a select result with an object in it more than once, e.g., in some joins. If you don't want this, you can add the keyword argument MyClass.select(..., distinct=True), which results in a SELECT DISTINCT call.

You can get the length of the result without fetching all the results by calling count on the result object, like MyClass.select().count(). A COUNT(*) query is used -- the actual objects are not fetched from the database. Together with slicing, this makes batched queries easy to write:

start = 20 size = 10 query = Table.select() results = query[start:start+size] total = query.count() print "Showing page %i of %i" % (start/size + 1, total/size + 1)

Note

There are several factors when considering the efficiency of this kind of batching, and it depends very much how the batching is being used. Consider a web application where you are showing an average of 100 results, 10 at a time, and the results are ordered by the date they were added to the database. While slicing will keep the database from returning all the results (and so save some communication time), the database will still have to scan through the entire result set to sort the items (so it knows which the first ten are), and depending on your query may need to scan through the entire table (depending on your use of indexes). Indexes are probably the most important way to improve importance in a case like this, and you may find caching to be more effective than slicing.

In this case, caching would mean retrieving the complete results. You can use list(MyClass.select(...)) to do this. You can save these results for some limited period of time, as the user looks through the results page by page. This means the first page in a search result will be slightly more expensive, but all later pages will be very cheap.

For more information on the where clause in the queries, see the SQLBuilder documentation.

q-magic

Please note the use of the q attribute in examples above. q is an object that returns special objects to construct SQL expressions. Operations on objects returned by q-magic are not evaluated immediately but stored in a manner similar to symbolic algebra; the entire expression is evaluated by constructing a string that is sent then to the backend.

For example, for the code:

>>> peeps = Person.select(Person.q.firstName=="John")

SQLObject doesn't evaluate firstName but stores the expression:

Person.q.firstName=="John"

converts it to the string first_name = 'John' and passes the string to the backend.

selectBy Method

An alternative to .select is .selectBy. It works like:

>>> peeps = Person.selectBy(firstName="John", lastName="Doe")

Each keyword argument is a column, and all the keyword arguments are ANDed together. The return value is a SelectResult, so you can slice it, count it, order it, etc.

Lazy Updates

By default SQLObject sends an UPDATE to the database for every attribute you set, or every time you call .set(). If you want to avoid this many updates, add lazyUpdate = True to your class sqlmeta definition.

Then updates will only be written to the database when you call inst.syncUpdate() or inst.sync(): .sync() also refetches the data from the database, which .syncUpdate() does not do.

When enabled instances will have a property .sqlmeta.dirty, which indicates if there are pending updates. Inserts are still done immediately; there's no way to do lazy inserts at this time.

One-to-Many Relationships

An address book is nothing without addresses.

First, let's define the new address table. People can have multiple addresses, of course:

>>> class Address(SQLObject):
...
...     street = StringCol()
...     city = StringCol()
...     state = StringCol(length=2)
...     zip = StringCol(length=9)
...     person = ForeignKey('Person')
>>> Address.createTable()
[]

Note the column person = ForeignKey("Person"). This is a reference to a Person object. We refer to other classes by name (with a string). In the database there will be a person_id column, type INT, which points to the person column.

Note

The reason SQLObject uses strings to refer to other classes is because the other class often does not yet exist. Classes in Python are created, not declared; so when a module is imported the commands are executed. class is just another command; one that creates a class and assigns it to the name you give.

If class A referred to class B, but class B was defined below A in the module, then when the A class was created (including creating all its column attributes) the B class simply wouldn't exist. By referring to classes by name, we can wait until all the required classes exist before creating the links between classes.

We want an attribute that gives the addresses for a person. In a class definition we'd do:

class Person(SQLObject):
    ...
    addresses = MultipleJoin('Address')

But we already have the class. We can add this to the class in-place:

>>> Person.sqlmeta.addJoin(MultipleJoin('Address',
...                        joinMethodName='addresses'))

Note

In almost all cases you can modify SQLObject classes after they've been created. Having attributes that contain *Col objects in the class definition is equivalent to calling certain class methods (like addColumn()).

Now we can get the backreference with aPerson.addresses, which returns a list. An example:

>>> p.addresses
[]
>>> Address(street='123 W Main St', city='Smallsville',
...         state='MN', zip='55407', person=p)
<Address 1 ...>
>>> p.addresses
[<Address 1 ...>]

Note

MultipleJoin, as well as RelatedJoin, returns a list of results. It is often preferable to get a SelectResults object instead, in which case you should use SQLMultipleJoin and SQLRelatedJoin. The declaration of these joins is unchanged from above, but the returned iterator has many additional useful methods.

Many-to-Many Relationships

For this example we will have user and role objects. The two have a many-to-many relationship, which is represented with the RelatedJoin.

>>> class User(SQLObject):
...
...     class sqlmeta:
...         # user is a reserved word in some databases, so we won't
...         # use that for the table name:
...         table = "user_table"
...
...     username = StringCol(alternateID=True, length=20)
...     # We'd probably define more attributes, but we'll leave
...     # that exercise to the reader...
...
...     roles = RelatedJoin('Role')

>>> class Role(SQLObject):
...
...     name = StringCol(alternateID=True, length=20)
...
...     users = RelatedJoin('User')

>>> User.createTable()
[]
>>> Role.createTable()
[]

Note

The sqlmeta class is used to store different kinds of metadata (and override that metadata, like table). This is new in SQLObject 0.7. See the section Class sqlmeta for more information on how it works and what attributes have special meanings.

And usage:

>>> bob = User(username='bob')
>>> tim = User(username='tim')
>>> jay = User(username='jay')
>>> admin = Role(name='admin')
>>> editor = Role(name='editor')
>>> bob.addRole(admin)
>>> bob.addRole(editor)
>>> tim.addRole(editor)
>>> bob.roles
[<Role 1 name='admin'>, <Role 2 name='editor'>]
>>> tim.roles
[<Role 2 name='editor'>]
>>> jay.roles
[]
>>> admin.users
[<User 1 username='bob'>]
>>> editor.users
[<User 1 username='bob'>, <User 2 username='tim'>]

In the process an intermediate table is created, role_user, which references both of the other classes. This table is never exposed as a class, and its rows do not have equivalent Python objects -- this hides some of the nuisance of a many-to-many relationship.

By the way, if you want to create an intermediate table of your own, maybe with additional columns, be aware that the standard SQLObject methods add/removesomething may not work as expected. Assuming that you are providing the join with the correct joinColumn and otherColumn arguments, be aware it's not possible to insert extra data via such methods, nor will they set any default value.

Let's have an example: in the previous User/Role system, you're creating a UserRole intermediate table, with the two columns containing the foreign keys for the MTM relationship, and an additional DateTimeCol defaulting to datetime.datetime.now : that column will stay empty when adding roles with the addRole method. If you want to get a list of rows from the intermediate table directly add a MultipleJoin to User or Role class.

You may notice that the columns have the extra keyword argument alternateID. If you use alternateID=True, this means that the column uniquely identifies rows -- like a username uniquely identifies a user. This identifier is in addition to the primary key (id), which is always present.

Note

SQLObject has a strong requirement that the primary key be unique and immutable. You cannot change the primary key through SQLObject, and if you change it through another mechanism you can cause inconsistency in any running SQLObject program (and in your data). For this reason meaningless integer IDs are encouraged -- something like a username that could change in the future may uniquely identify a row, but it may be changed in the future. So long as it is not used to reference the row, it is also safe to change it in the future.

A alternateID column creates a class method, like byUsername for a column named username (or you can use the alternateMethodName keyword argument to override this). Its use:

>>> User.byUsername('bob')
<User 1 username='bob'>
>>> Role.byName('admin')
<Role 1 name='admin'>

Selecting Objects Using Relationships

An select expression can refer to multiple classes, like:

>>> Person._connection.debug = False # Needed for doctests
>>> peeps = Person.select(
...         AND(Address.q.personID == Person.q.id,
...             Address.q.zip.startswith('504')))
>>> list(peeps)
[]
>>> peeps = Person.select(
...         AND(Address.q.personID == Person.q.id,
...             Address.q.zip.startswith('554')))
>>> list(peeps)
[<Person 2 firstName='Robert' middleInitial='Q' lastName='Hope Jr.'>]

It is also possible to use the q attribute when constructing complex queries, like:

>>> Person._connection.debug = False  # Needed for doctests
>>> peeps = Person.select("""address.person_id = person.id AND
...                          address.zip LIKE '504%'""",
...                       clauseTables=['address'])

Note that you have to use clauseTables if you use tables besides the one you are selecting from. If you use the q attributes SQLObject will automatically figure out what extra classes you might have used.

Class sqlmeta

This new class is available starting with SQLObject 0.7 and allows specifying metadata in a clearer way, without polluting the class namespace with more attributes.

There are some special attributes that can be used inside this class that will change the behavior of the class that contains it. Those values are:

table:
The name of the table in the database. This is derived from style and the class name if no explicit name is given. If you don't give a name and haven't defined an alternative style, then the standard MixedCase to mixed_case translation is performed.
idName:
The name of the primary key column in the database. This is derived from style if no explicit name is given. The default name is id.
idType:
A function that coerces/normalizes IDs when setting IDs. This is int by default (all IDs are normalized to integers).
style:
A style object -- this object allows you to use other algorithms for translating between Python attribute and class names, and the database's column and table names. See Changing the Naming Style for more. It is an instance of the IStyle interface.
lazyUpdate:
A boolean (default false). If true, then setting attributes on instances (or using inst.set(.) will not send UPDATE queries immediately (you must call inst.syncUpdates() or inst.sync() first).
defaultOrder:
When selecting objects and not giving an explicit order, this attribute indicates the default ordering. It is like this value is passed to .select() and related methods; see those method's documentation for details.
cacheValues:

A boolean (default true). If true, then the values in the row are cached as long as the instance is kept (and inst.expire() is not called).

If set to False then values for attributes from the database won't be cached. So every time you access an attribute in the object the database will be queried for a value, i.e., a SELECT will be issued. If you want to handle concurrent access to the database from multiple processes then this is probably the way to do so.

registry:
Because SQLObject uses strings to relate classes, and these strings do not respect module names, name clashes will occur if you put different systems together. This string value serves as a namespace for classes.
fromDatabase:
A boolean (default false). If true, then on class creation the database will be queried for the table's columns, and any missing columns (possible all columns) will be added automatically.
dbEncoding:
UnicodeCol looks up sqlmeta.dbEncoding if column.dbEncoding is None (if sqlmeta.dbEncoding is None UnicodeCol looks up connection.dbEncoding and if dbEncoding isn't defined anywhere it defaults to "utf-8").

The following attributes provide introspection but should not be set directly - see Runtime Column and Join Changes for dynamically modifying these class elements.

columns:
A dictionary of {columnName: anSOColInstance}. You can get information on the columns via this read-only attribute.
columnList:
A list of the values in columns. Sometimes a stable, ordered version of the columns is necessary; this is used for that.
columnDefinitions:
A dictionary like columns, but contains the original column definitions (which are not class-specific, and have no logic).
joins:
A list of all the Join objects for this class.
indexes:
A list of all the indexes for this class.
createSQL:
SQL queries run after table creation. createSQL can be a string with a single SQL command, a list of SQL commands, or a dictionary with keys that are dbNames and values that are either single SQL command string or a list of SQL commands. This is usually for ALTER TABLE commands.

There is also one instance attribute:

expired:
A boolean. If true, then the next time this object's column attributes are accessed a query will be run.

While in previous versions of SQLObject those attributes were defined directly at the class that will map your database data to Python and all of them were prefixed with an underscore, now it is suggested that you change your code to this new style. The old way was removed in SQLObject 0.8.

Please note: when using InheritedSQLObject, sqlmeta attributes don't get inherited, e.g. you can't access via the sqlmeta.columns dictionary the parent's class column objects.

Using sqlmeta

To use sqlmeta you should write code like this example:

class MyClass(SQLObject):

    class sqlmeta:
        lazyUpdate = True
        cacheValues = False

    columnA = StringCol()
    columnB = IntCol()

    def _set_attr1(self, value):
        # do something with value

    def _get_attr1(self):
        # do something to retrieve value

The above definition is creating a table my_class (the name may be different if you change the style used) with two columns called columnA and columnB. There's also a third field that can be accessed using MyClass.attr1. The sqlmeta class is changing the behavior of MyClass so that it will perform lazy updates (you'll have to call the .sync() method to write the updates to the database) and it is also telling that MyClass won't have any cache, so that every time you ask for some information it will be retrieved from the database.

j-magic

There is a magic attribute j similar to q with attributes for ForeignKey and SQLMultipleJoin/SQLRelatedJoin, providing a shorthand for the SQLBuilder join expressions to traverse the given relationship. For example, for a ForeignKey AClass.j.someB is equivalent to (AClass.q.someBID==BClass.q.id), as is BClass.j.someAs for the matching SQLMultipleJoin.

SQLObject Class

There is one special attribute - _connection. It is the connection defined for the table.

_connection:

The connection object to use, from DBConnection. You can also set the variable __connection__ in the enclosing module and it will be picked up (be sure to define __connection__ before your class). You can also pass a connection object in at instance creation time, as described in transactions.

If you have defined sqlhub.processConnection then this attribute can be omitted from your class and the sqlhub will be used instead. If you have several classes using the same connection that might be an advantage, besides saving a lot of typing.

Customizing the Objects

While we haven't done so in the examples, you can include your own methods in the class definition. Writing your own methods should be obvious enough (just do so like in any other class), but there are some other details to be aware of.

Initializing the Objects

There are two ways SQLObject instances can come into existence: they can be fetched from the database, or they can be inserted into the database. In both cases a new Python object is created. This makes the role of __init__ a little confusing.

In general, you should not touch __init__. Instead use the _init method, which is called after an object is fetched or inserted. This method has the signature _init(self, id, connection=None, selectResults=None), though you may just want to use _init(self, *args, **kw). Note: don't forget to call SQLObject._init(self, *args, **kw) if you override the method!

Adding Magic Attributes (properties)

You can use all the normal techniques for defining methods in this new-style class, including classmethod, staticmethod, and property, but you can also use a shortcut. If you have a method that's name starts with _set_, _get_, _del_, or _doc_, it will be used to create a property. So, for instance, say you have images stored under the ID of the person in the /var/people/images directory:

class Person(SQLObject):
    # ...

    def imageFilename(self):
        return 'images/person-%s.jpg' % self.id

    def _get_image(self):
        if not os.path.exists(self.imageFilename()):
            return None
        f = open(self.imageFilename())
        v = f.read()
        f.close()
        return v

    def _set_image(self, value):
        # assume we get a string for the image
        f = open(self.imageFilename(), 'w')
        f.write(value)
        f.close()

    def _del_image(self, value):
        # I usually wouldn't include a method like this, but for
        # instructional purposes...
        os.unlink(self.imageFilename())

Later, you can use the .image property just like an attribute, and the changes will be reflected in the filesystem by calling these methods. This is a good technique for information that is better to keep in files as opposed to the database (such as large, opaque data like images).

You can also pass an image keyword argument to the constructor or the set method, like Person(..., image=imageText).

All of the methods (_get_, _set_, etc) are optional -- you can use any one of them without using the others. So you could define just a _get_attr method so that attr was read-only.

Overriding Column Attributes

It's a little more complicated if you want to override the behavior of an database column attribute. For instance, imagine there's special code you want to run whenever someone's name changes. In many systems you'd do some custom code, then call the superclass's code. But the superclass (SQLObject) doesn't know anything about the column in your subclass. It's even worse with properties.

SQLObject creates methods like _set_lastName for each of your columns, but again you can't use this, since there's no superclass to reference (and you can't write SQLObject._set_lastName(...), because the SQLObject class doesn't know about your class's columns). You want to override that _set_lastName method yourself.

To deal with this, SQLObject creates two methods for each getter and setter, for example: _set_lastName and _SO_set_lastName. So to intercept all changes to lastName:

class Person(SQLObject):
    lastName = StringCol()
    firstName = StringCol()

    def _set_lastName(self, value):
        self.notifyLastNameChange(value)
        self._SO_set_lastName(value)

Or perhaps you want to constrain a phone numbers to be actual digits, and of proper length, and make the formatting nice:

import re

class PhoneNumber(SQLObject):
    phoneNumber = StringCol(length=30)

    _garbageCharactersRE = re.compile(r'[\-\.\(\) ]')
    _phoneNumberRE = re.compile(r'^[0-9]+$')
    def _set_phoneNumber(self, value):
        value = self._garbageCharactersRE.sub('', value)
        if not len(value) >= 10:
            raise ValueError(
                'Phone numbers must be at least 10 digits long')
        if not self._phoneNumberRE.match(value):
            raise ValueError, 'Phone numbers can contain only digits'
        self._SO_set_phoneNumber(value)

    def _get_phoneNumber(self):
        value = self._SO_get_phoneNumber()
        number = '(%s) %s-%s' % (value[0:3], value[3:6], value[6:10])
        if len(value) > 10:
            number += ' ext.%s' % value[10:]
        return number

Note

You should be a little cautious when modifying data that gets set in an attribute. Generally someone using your class will expect that the value they set the attribute to will be the same value they get back. In this example we removed some of the characters before putting it in the database, and reformatted it on the way out. One advantage of methods (as opposed to attribute access) is that the programmer is more likely to expect this disconnect.

Also note while these conversions will take place when getting and setting the column, in queries the conversions will not take place. So if you convert the value from a "Pythonic" representation to a "SQLish" representation, your queries (when using .select() and .selectBy()) will have to be in terms of the SQL/Database representation (as those commands generate SQL that is run on the database).

Undefined attributes

There's one more thing worth telling, because you may something get strange results when making a typo. SQLObject won't ever complain or raise any error when setting a previously undefined attribute; it will simply set it, without making any change to the database, i.e: it will work as any other attribute you set on any Python class, it will 'forget' it is a SQLObject class.

This may sometimes be a problem: if you have got a 'name' attribute and you you write 'a.namme="Victor"' once, when setting it, you'll get no error, no warning, nothing at all, and you may get crazy at understanding why you don't get that value set in your DB.

Reference

The instructions above should tell you enough to get you started, and be useful for many situations. Now we'll show how to specify the class more completely.

Col Class: Specifying Columns

The list of columns is a list of Col objects. These objects don't have functionality in themselves, but give you a way to specify the column.

dbName:
This is the name of the column in the database. If you don't give a name, your Pythonic name will be converted from mixed-case to underscore-separated.
default:
The default value for this column. Used when creating a new row. If you give a callable object or function, the function will be called, and the return value will be used. So you can give DateTimeCol.now to make the default value be the current time. Or you can use sqlbuilder.func.NOW() to have the database use the NOW() function internally. If you don't give a default there will be an exception if this column isn't specified in the call to new.
defaultSQL:
DEFAULT SQL attribute.
alternateID:

This boolean (default False) indicates if the column can be used as an ID for the field (for instance, a username), though it is not a primary key. If so a class method will be added, like byUsername which will return that object. Use alternateMethodName if you don't like the by* name (e.g. alternateMethodName="username").

The column should be declared UNIQUE in your table schema.

unique:
If true, when SQLObject creates a table it will declare this column to be UNIQUE.
notNone:
If true, None/NULL is not allowed for this column. Useful if you are using SQLObject to create your tables.
sqlType:
The SQL type for this column (like INT, BOOLEAN, etc). You can use classes (defined below) for this, but if those don't work it's sometimes easiest just to use sqlType. Only necessary if SQLObject is creating your tables.
validator:
formencode-like validator. Making long story short, this is an object that provides to_python() and from_python() to validate and convert (adapt or cast) the values when they are read/written from/to the database. You should see formencode validator documentation for more details. This validator is appended to the end of the list of the list of column validators. If the column has a list of validators their from_python() methods are ran from the beginnig of the list to the end; to_python() in the reverse order. That said, from_python() method of this validator is called last, after all validators in the list; to_python() is called first.
validator2:
Another validator. It is inserted in the beginning of the list of the list of validators, i.e. its from_python() method is called first; to_python() last.

Column Types

The ForeignKey class should be used instead of Col when the column is a reference to another table/class. It is generally used like ForeignKey('Role'), in this instance to create a reference to a table Role. This is largely equivalent to Col(foreignKey='Role', sqlType='INT'). Two attributes will generally be created, role, which returns a Role instance, and roleID, which returns an integer ID for the related role.

There are some other subclasses of Col. These are used to indicate different types of columns, when SQLObject creates your tables.

BLOBCol:
A column for binary data. Presently works only with MySQL, PostgreSQL and SQLite backends.
BoolCol:
Will create a BOOLEAN column in Postgres, or INT in other databases. It will also convert values to "t"/"f" or 0/1 according to the database backend.
CurrencyCol:
Equivalent to DecimalCol(size=10, precision=2). WARNING: as DecimalCol MAY NOT return precise numbers, this column may share the same behavior. Please read the DecimalCol warning.
DateTimeCol:
A date and time (usually returned as an datetime or mxDateTime object).
DateCol:
A date (usually returned as an datetime or mxDateTime object).
TimeCol:
A time (usually returned as an datetime or mxDateTime object).
TimestampCol:
Supports MySQL TIMESTAMP type.
DecimalCol:
Base-10, precise number. Uses the keyword arguments size for number of digits stored, and precision for the number of digits after the decimal point. WARNING: it may happen that DecimalCol values, although correctly stored in the DB, are returned as floats instead of decimals. For example, due to the type affinity SQLite stores decimals as integers or floats (NUMERIC storage class). You should test with your database adapter, and you should try importing the Decimal type and your DB adapter before importing SQLObject.
DecimalStringCol:
Similar to DecimalCol but stores data as strings to work around problems in some drivers and type affinity problem in SQLite. As it stores data as strings the column cannot be used in SQL expressions (column1 + column2) and probably will has problems with ORDER BY.
EnumCol:

One of several string values -- give the possible strings as a list, with the enumValues keyword argument. MySQL has a native ENUM type, but will work with other databases too (storage just won't be as efficient).

For PostgreSQL, EnumCol's are implemented using check constraints. Due to the way PostgreSQL handles check constraints involving NULL, specifying None as a member of an EnumCol will effectively mean that, at the SQL level, the check constraint will be ignored (see http://archives.postgresql.org/pgsql-sql/2004-12/msg00065.php for more details).

SetCol:
Supports MySQL SET type.
FloatCol:
Floats.
ForeignKey:
A key to another table/class. Use like user = ForeignKey('User'). It can check for referential integrity using the keyword argument cascade, please see ForeignKey for details.
IntCol:
Integers.
JsonbCol:
A column for jsonb objects. Only supported on Postgres. Any Python object that can be serialized with json.dumps can be stored.
JSONCol:
A universal json column that converts simple Python objects (None, bool, int, float, long, dict, list, str/unicode to/from JSON using json.dumps/loads. A subclass of StringCol.
PickleCol:
An extension of BLOBCol; this column can store/retrieve any Python object; it actually (un)pickles the object from/to string and stores/retrieves the string. One can get and set the value of the column but cannot search (use it in WHERE).
StringCol:

A string (character) column. Extra keywords:

length:
If given, the type will be something like VARCHAR(length). If not given, then TEXT is assumed (i.e., lengthless).
varchar:
A boolean; if you have a length, differentiates between CHAR and VARCHAR, default True, i.e., use VARCHAR.
UnicodeCol:

A subclass of StringCol. Also accepts a dbEncoding keyword argument, it defaults to None which means to lookup dbEncoding in sqlmeta and connection, and if dbEncoding isn't defined anywhere it defaults to "utf-8". Values coming in and out from the database will be encoded and decoded. Note: there are some limitations on using UnicodeCol in queries:

  • only simple q-magic fields are supported; no expressions;
  • only == and != operators are supported;

The following code works:

MyTable.select(u'value' == MyTable.q.name)
MyTable.select(MyTable.q.name != u'value')
MyTable.select(OR(MyTable.q.col1 == u'value1', MyTable.q.col2 != u'value2'))
MyTable.selectBy(name = u'value')
MyTable.selectBy(col1=u'value1', col2=u'value2')
MyTable.byCol1(u'value1') # if col1 is an alternateID

The following does not work:

MyTable.select((MyTable.q.name + MyTable.q.surname) == u'value')

In that case you must apply the encoding yourself:

MyTable.select((MyTable.q.name + MyTable.q.surname) == u'value'.encode(dbEncoding))
UuidCol:
A column for UUID. On Postgres uses 'UUID' data type, on all other backends uses VARCHAR(36).

Relationships Between Classes/Tables

ForeignKey

You can use the ForeignKey to handle foreign references in a table, but for back references and many-to-many relationships you'll use joins.

ForeignKey allows you to specify referential integrity using the keyword cascade, which can have these values:

None:
No action is taken on related deleted columns (this is the default). Following the Person/Address example, if you delete the object Person with id 1 (John Doe), the Address with id 1 (123 W Main St) will be kept untouched (with personID=1).
False:
Deletion of an object that has other objects related to it using a ForeignKey will fail (sets ON DELETE RESTRICT). Following the Person/Address example, if you delete the object Person with id 1 (John Doe) a SQLObjectIntegrityError exception will be raised, because the Address with id 1 (123 W Main St) has a reference (personID=1) to it.
True:
Deletion of an object that has other objects related to it using a ForeignKey will delete all the related objects too (sets ON DELETE CASCADE). Following the Person/Address example, if you delete the object Person with id 1 (John Doe), the Address with id 1 (123 W Main St) will be deleted too.
'null':
Deletion of an object that has other objects related to it using a ForeignKey will set the ForeignKey column to NULL/None (sets ON DELETE SET NULL). Following the Person/Address example, if you delete the object Person with id 1 (John Doe), the Address with id 1 (123 W Main St) will be kept but the reference to person will be set to NULL/None (personID=None).

MultipleJoin and SQLMultipleJoin: One-to-Many

See One-to-Many Relationships for an example of one-to-many relationships.

MultipleJoin returns a list of results, while SQLMultipleJoin returns a SelectResults object.

Several keyword arguments are allowed to the MultipleJoin constructor:

joinColumn:
The column name of the key that points to this table. So, if you have a table Product, and another table has a column ProductNo that points to this table, then you'd use joinColumn="ProductNo". WARNING: the argument you pass must conform to the column name in the database, not to the column in the class. So, if you have a SQLObject containing the ProductNo column, this will probably be translated into product_no_id in the DB (product_no is the normal uppercase- to-lowercase + underscores SQLO Translation, the added _id is just because the column referring to the table is probably a ForeignKey, and SQLO translates foreign keys that way). You should pass that parameter.
orderBy:
Like the orderBy argument to select(), you can specify the order that the joined objects should be returned in. defaultOrder will be used if not specified; None forces unordered results.
joinMethodName:
When adding joins dynamically (using the class method addJoin), you can give the name of the accessor for the join. It can also be created automatically, and is normally implied (i.e., addresses = MultipleJoin(...) implies joinMethodName="addresses").

RelatedJoin and SQLRelatedJoin: Many-to-Many

See Many-to-Many Relationships for examples of using many-to-many joins.

RelatedJoin returns a list of results, while SQLRelatedJoin returns a SelectResults object.

RelatedJoin has all the keyword arguments of MultipleJoin, plus:

otherColumn:
Similar to joinColumn, but referring to the joined class. Same warning about column name.
intermediateTable:
The name of the intermediate table which references both classes. WARNING: you should pass the database table name, not the SQLO class representing.
addRemoveName:
In the user/role example, the methods addRole(role) and removeRole(role) are created. The Role portion of these method names can be changed by giving a string value here.
createRelatedTable:
default: True. If False, then the related table won't be automatically created; instead you must manually create it (e.g., with explicit SQLObject classes for the joins). New in 0.7.1.

Note

Let's suppose you have SQLObject-inherited classes Alpha and Beta, and an AlphasAndBetas used for the many-to-many relationship. AlphasAndBetas contains the alphaIndex Foreign Key column referring to Alpha, and the betaIndex FK column referring to Beta. if you want a 'betas' RelatedJoin in Alpha, you should add it to Alpha passing 'Beta' (class name!) as the first parameter, then passing 'alpha_index_id' as joinColumn, 'beta_index_id' as otherColumn, and 'alphas_and_betas' as intermediateTable.

An example schema that requires the use of joinColumn, otherColumn, and intermediateTable:

CREATE TABLE person (
    id SERIAL,
    username VARCHAR(100) NOT NULL UNIQUE
);

CREATE TABLE role (
    id SERIAL,
    name VARCHAR(50) NOT NULL UNIQUE
);

CREATE TABLE assigned_roles (
    person INT NOT NULL,
    role INT NOT NULL
);

Then the usage in a class:

class Person(SQLObject):
    username = StringCol(length=100, alternateID=True)
    roles = RelatedJoin('Role', joinColumn='person', otherColumn='role',
                        intermediateTable='assigned_roles')
class Role(SQLObject):
    name = StringCol(length=50, alternateID=True)
    roles = RelatedJoin('Person', joinColumn='role', otherColumn='person',
                        intermediateTable='assigned_roles')

SingleJoin: One-to-One

Similar to MultipleJoin, but returns just one object, not a list.

Connection pooling

Connection object acquires a new low-level DB API connection from the pool and stores it; the low-level connection is removed from the pool; "releasing" means "return it to the pool". For single-threaded programs there is one connection in the pool.

If the pool is empty a new low-level connection opened; if one has disabled pooling (by setting conn._pool = None) the connection will be closed instead of returning to the pool.

Transactions

Transaction support in SQLObject is left to the database. Transactions can be used like:

conn = DBConnection.PostgresConnection('yada')
trans = conn.transaction()
p = Person.get(1, trans)
p.firstName = 'Bob'
trans.commit()
p.firstName = 'Billy'
trans.rollback()

The trans object here is essentially a wrapper around a single database connection, and commit and rollback just pass that message to the low-level connection.

One can call as much .commit()'s, but after a .rollback() one has to call .begin(). The last .commit() should be called as .commit(close=True) to release low-level connection back to the connection pool.

You can use SELECT FOR UPDATE in those databases that support it:

Person.select(Person.q.name=="value", forUpdate=True, connection=trans)

Method sqlhub.doInTransaction can be used to run a piece of code in a transaction. The method accepts a callable and positional and keywords arguments. It begins a transaction using its processConnection or threadConnection, calls the callable, commits the transaction and closes the underlying connection; it returns whatever the callable returned. If an error occurs during call to the callable it rolls the transaction back and reraise the exception.

Automatic Schema Generation

All the connections support creating and dropping tables based on the class definition. First you have to prepare your class definition, which means including type information in your columns.

Indexes

You can also define indexes for your tables, which is only meaningful when creating your tables through SQLObject (SQLObject relies on the database to implement the indexes). You do this again with attribute assignment, like:

firstLastIndex = DatabaseIndex('firstName', 'lastName')

This creates an index on two columns, useful if you are selecting a particular name. Of course, you can give a single column, and you can give the column object (firstName) instead of the string name. Note that if you use unique or alternateID (which implies unique) the database may make an index for you, and primary keys are always indexed.

If you give the keyword argument unique to DatabaseIndex you'll create a unique index -- the combination of columns must be unique.

You can also use dictionaries in place of the column names, to add extra options. E.g.:

lastNameIndex = DatabaseIndex({'expression': 'lower(last_name)'})

In that case, the index will be on the lower-case version of the column. It seems that only PostgreSQL supports this. You can also do:

lastNameIndex = DatabaseIndex({'column': lastName, 'length': 10})

Which asks the database to only pay attention to the first ten characters. Only MySQL supports this, but it is ignored in other databases.

Creating and Dropping Tables

To create a table call createTable. It takes two arguments:

ifNotExists:
If the table already exists, then don't try to create it. Default False.
createJoinTables:
If you used Many-to-Many relationships, then the intermediate tables will be created (but only for one of the two involved classes). Default True.

dropTable takes arguments ifExists and dropJoinTables, self-explanatory.

Dynamic Classes

SQLObject classes can be manipulated dynamically. This leaves open the possibility of constructing SQLObject classes from an XML file, from database introspection, or from a graphical interface.

Automatic Class Generation

SQLObject can read the table description from the database, and fill in the class columns (as would normally be described in the _columns attribute). Do this like:

class Person(SQLObject):
    class sqlmeta:
        fromDatabase = True

You can still specify columns (in _columns), and only missing columns will be added.

Runtime Column and Join Changes

You can add and remove columns to your class at runtime. Such changes will effect all instances, since changes are made in place to the class. There are two methods of the class sqlmeta object, addColumn and delColumn, both of which take a Col object (or subclass) as an argument. There's also an option argument changeSchema which, if True, will add or drop the column from the database (typically with an ALTER command).

When adding columns, you must pass the name as part of the column constructor, like StringCol("username", length=20). When removing columns, you can either use the Col object (as found in sqlmeta.columns, or which you used in addColumn), or you can use the column name (like MyClass.delColumn("username")).

You can also add Joins, like MyClass.addJoin(MultipleJoin("MyOtherClass")), and remove joins with delJoin. delJoin does not take strings, you have to get the join object out of the sqlmeta.joins attribute.

Legacy Database Schemas

Often you will have a database that already exists, and does not use the naming conventions that SQLObject expects, or does not use any naming convention at all.

SQLObject requirements

While SQLObject tries not to make too many requirements on your schema, some assumptions are made. Some of these may be relaxed in the future.

All tables that you want to turn into a class need to have an integer primary key. That key should be defined like:

MySQL:
INT PRIMARY KEY AUTO_INCREMENT
Postgres:
SERIAL PRIMARY KEY
SQLite:
INTEGER PRIMARY KEY

SQLObject does not support primary keys made up of multiple columns (that probably won't change). It does not generally support tables with primary keys with business meaning -- i.e., primary keys are assumed to be immutable (that won't change).

At the moment foreign key column names must end in "ID" (case-insensitive). This restriction will probably be removed in the next release.

Workaround for primary keys made up of multiple columns

If the database table/view has ONE NUMERIC Primary Key then sqlmeta - idName should be used to map the table column name to SQLObject id column.

If the Primary Key consists only of number columns it is possible to create a virtual column id this way:

Example for Postgresql:

select '1'||lpad(PK1,max_length_of_PK1,'0')||lpad(PK2,max_length_of_PK2,'0')||...||lpad(PKn,max_length_of_PKn,'0') as "id", column_PK1, column_PK2, .., column_PKn, column... from table;

Note:

  • The arbitrary '1' at the beginning of the string to allow for leading zeros of the first PK.
  • The application designer has to determine the maximum length of each Primary Key.

This statement can be saved as a view or the column can be added to the database table, where it can be kept up to date with a database trigger.

Obviously the "view" method does generally not allow insert, updates or deletes. For Postgresql you may want to consult the chapter "RULES" for manipulating underlying tables.

For an alphanumeric Primary Key column a similar method is possible:

Every character of the lpaded PK has to be transfered using ascii(character) which returns a 3digit number which can be concatenated as shown above.

Caveats:

  • this way the id may become a very large integer number which may cause troubles elsewhere.
  • no performance loss takes place if the where clauses specifies the PK columns.

Example: CD-Album * Album: PK=ean * Tracks: PK=ean,disc_nr,track_nr

The database view to show the tracks starts:

SELECT ean||lpad("disc_nr",2,'0')||lpad("track_nr",2,'0') as id, ... Note: no leading '1' and no padding necessary for ean numbers

Tracks.select(Tracks.q.ean==id) ... where id is the ean of the Album.

Changing the Naming Style

By default names in SQLObject are expected to be mixed case in Python (like mixedCase), and underscore-separated in SQL (like mixed_case). This applies to table and column names. The primary key is assumed to be simply id.

Other styles exist. A typical one is mixed case column names, and a primary key that includes the table name, like ProductID. You can use a different Style object to indicate a different naming convention. For instance:

class Person(SQLObject):
    class sqlmeta:
        style = MixedCaseStyle(longID=True)
    firstName = StringCol()
    lastName = StringCol()

If you use Person.createTable(), you'll get:

CREATE TABLE Person (
    PersonID INT PRIMARY KEY,
    FirstName Text,
    LastName Text
)

The MixedCaseStyle object handles the initial capitalization of words, but otherwise leaves them be. By using longID=True, we indicate that the primary key should look like a normal reference (PersonID for MixedCaseStyle, or person_id for the default style).

If you wish to change the style globally, assign the style to the connection, like:

__connection__.style = MixedCaseStyle(longID=True)

Irregular Naming

This is now covered in the Class sqlmeta section.

Non-Integer Keys

While not strictly a legacy database issue, this fits into the category of "irregularities". If you use non-integer keys, all primary key management is up to you. You must create the table yourself (SQLObject can create tables with int or str IDs), and when you create instances you must pass a id keyword argument into constructor (like Person(id='555-55-5555', ...)).

DBConnection: Database Connections

The DBConnection module currently has six external classes, MySQLConnection, PostgresConnection, SQLiteConnection, SybaseConnection, MaxdbConnection, MSSQLConnection.

You can pass the keyword argument debug to any connector. If set to true, then any SQL sent to the database will also be printed to the console.

You can additionally pass logger keyword argument which should be a name of the logger to use. If specified and debug is True, SQLObject will write debug print statements via that logger instead of printing directly to console. The argument loglevel allows to choose the logging level - it can be debug, info, warning, error, critical or exception. In case logger is absent or empty SQLObject uses print's instead of logging; loglevel can be stdout or stderr in this case; default is stdout.

To configure logging one can do something like that:

import logging
logging.basicConfig()
for handler in logging.root.handlers[:]:
   logging.root.removeHandler(handler)
handler = logging.FileHandler("test.log")
fmt = '[%(asctime)s] %(name)s %(levelname)s: %(message)s'
handler.setFormatter(logging.Formatter(fmt))
logging.root.addHandler(handler)
logging.root.setLevel(logging.DEBUG)
log = logging.getLogger("TEST")
log.info("Log started")

__connection__ = "sqlite:/:memory:?debug=1&logger=TEST&loglevel=debug"

The code redirects SQLObject debug messages to the test.log file.

MySQL

MySQLConnection takes the keyword arguments host, port, db, user, and password, just like MySQLdb.connect does.

MySQLConnection supports all the features, though MySQL only supports transactions when using the InnoDB backend, and SQLObject currently does not have support for explicitly defining the backend when using createTable.

Keyword argument conv allows to pass a list of custom converters. Example:

import time
import sqlobject
import MySQLdb.converters

def _mysql_timestamp_converter(raw):
         """Convert a MySQL TIMESTAMP to a floating point number representing
         the seconds since the Un*x Epoch. It uses custom code the input seems
         to be the new (MySQL 4.1+) timestamp format, otherwise code from the
         MySQLdb module is used."""
         if raw[4] == '-':
             return time.mktime(time.strptime(raw, '%Y-%m-%d %H:%M:%S'))
         else:
             return MySQLdb.converters.mysql_timestamp_converter(raw)

conversions = MySQLdb.converters.conversions.copy()
conversions[MySQLdb.constants.FIELD_TYPE.TIMESTAMP] = _mysql_timestamp_converter

MySQLConnection = sqlobject.mysql.builder()
connection = MySQLConnection(user='foo', db='somedb', conv=conversions)

Postgres

PostgresConnection takes a single connection string, like "dbname=something user=some_user", just like psycopg.connect. You can also use the same keyword arguments as for MySQLConnection, and a dsn string will be constructed.

PostgresConnection supports transactions and all other features.

The user can choose a DB API driver for PostgreSQL by using a driver parameter in DB URI or PostgresConnection that can be a comma-separated list of driver names. Possible drivers are: psycopg2, psycopg1, psycopg (tries psycopg2 and psycopg1), pygresql. Default is psycopg.

SQLite

SQLiteConnection takes the a single string, which is the path to the database file.

SQLite puts all data into one file, with a journal file that is opened in the same directory during operation (the file is deleted when the program quits). SQLite does not restrict the types you can put in a column -- strings can go in integer columns, dates in integers, etc.

SQLite may have concurrency issues, depending on your usage in a multi-threaded environment.

The user can choose a DB API driver for SQLite by using a driver parameter in DB URI or SQLiteConnection that can be a comma-separated list of driver names. Possible drivers are: pysqlite2 (alias sqlite2), sqlite3, sqlite (alias sqlite1). Default is to test pysqlite2, sqlite3 and sqlite in that order.

Firebird

FirebirdConnection takes the arguments host, db, user (default "sysdba"), password (default "masterkey").

Firebird supports all the features. Support is still young, so there may be some issues, especially with concurrent access, and especially using lazy selects. Try list(MyClass.select()) to avoid concurrent cursors if you have problems (using list() will pre-fetch all the results of a select).

Firebird support uses fdb or kinterbasdb Python library.

There could be a problem if one tries to connect to a server running on w32 from a program running on Unix; the problem is how to specify the database so that SQLObject correctly parses it. Vertical bar is replaces by a semicolon only on a w32. On Unix a vertical bar is a pretty normal character and must not be processed.

The most correct way to fix the problem is to connect to the DB using a database name, not a file name. In the Firebird a DBA can set an alias instead of database name in the aliases.conf file

Example from Firebird 2.0 Administrators Manual:

# fbdb1 is on a Windows server:
fbdb1 = c:\Firebird\sample\Employee.fdb

Now a program can connect to firebird://host:port/fbdb1.

One can edit aliases.conf whilst the server is running. There is no need to stop and restart the server in order for new aliases.conf entries to be recognised.

If you are using indexes and get an error like key size exceeds implementation restriction for index, see this page to understand the restrictions on your indexing.

Sybase

SybaseConnection takes the arguments host, db, user, and password. It also takes the extra boolean argument locking (default True), which is passed through when performing a connection. You may use a False value for locking if you are not using multiple threads, for a slight performance boost.

It uses the Sybase module.

MAX DB

MAX DB, also known as SAP DB, is available from a partnership of SAP and MySQL. It takes the typical arguments: host, database, user, password. It also takes the arguments sqlmode (default "internal"), isolation, and timeout, which are passed through when creating the connection to the database.

It uses the sapdb module.

MS SQL Server

The MSSQLConnection objects wants to use new style connection strings in the format of

mssql://user:pass@host:port/db

This will then be mapped to either the correct driver format. If running SQL Server on a "named" port, make sure to specify the port number in the URI.

The two drivers currently supported are adodbapi and pymssql.

The user can choose a DB API driver for MSSQL by using a driver parameter in DB URI or MSSQLConnection that can be a comma-separated list of driver names. Possible drivers are: adodb (alias adodbapi) and pymssql. Default is to test adodbapi and pymssql in that order.

Events (signals)

Signals are a mechanism to be notified when data or schema changes happen through SQLObject. This may be useful for doing custom data validation, logging changes, setting default attributes, etc. Some of what signals can do is also possible by overriding methods, but signals may provide a cleaner way, especially across classes not related by inheritance.

Example:

from sqlobject.events import listen, RowUpdateSignal, RowCreatedSignal
from model import Users

def update_listener(instance, kwargs):
    """keep "last_updated" field current"""
    import datetime
    # BAD method 1, causes infinite recursion?
    # instance should be read-only
    instance.last_updated = datetime.datetime.now()
    # GOOD method 2
    kwargs['last_updated'] = datetime.datetime.now()

def created_listener(instance, kwargs, post_funcs):
    """"email me when new users added"""
    # email() implementation left as an exercise for the reader
    msg = "%s just was just added to the database!" % kwargs['name']
    email(msg)

listen(update_listener, Users, RowUpdateSignal)
listen(created_listener, Users, RowCreatedSignal)

Exported Symbols

You can use from sqlobject import *, though you don't have to. It exports a minimal number of symbols. The symbols exported:

From sqlobject.main:

  • NoDefault
  • SQLObject
  • getID
  • getObject

From sqlobject.col: * Col * StringCol * IntCol * FloatCol * KeyCol * ForeignKey * EnumCol * SetCol * DateTimeCol * DateCol * TimeCol * TimestampCol * DecimalCol * CurrencyCol

From sqlobject.joins: * MultipleJoin * RelatedJoin

From sqlobject.styles: * Style * MixedCaseUnderscoreStyle * DefaultStyle * MixedCaseStyle

From sqlobject.sqlbuilder:

  • AND
  • OR
  • NOT
  • IN
  • LIKE
  • DESC
  • CONTAINSSTRING
  • const
  • func

LEFT JOIN and other JOINs

First look in the FAQ, question "How can I do a LEFT JOIN?"

Still here? Well. To perform a JOIN use one of the JOIN helpers from SQLBuilder. Pass an instance of the helper to .select() method. For example:

from sqlobject.sqlbuilder import LEFTJOINOn
MyTable.select(
    join=LEFTJOINOn(Table1, Table2,
                    Table1.q.name == Table2.q.value))

will generate the query:

SELECT my_table.* FROM my_table, table1
LEFT JOIN table2 ON table1.name = table2.value;

If you want to join with the primary table - leave the first table None:

MyTable.select(
    join=LEFTJOINOn(None, Table1,
                    MyTable.q.name == Table1.q.value))

will generate the query:

SELECT my_table.* FROM my_table
LEFT JOIN table2 ON my_table.name = table1.value;

The join argument for .select() can be a JOIN() or a sequence (list/tuple) of JOIN()s.

Available joins are JOIN, INNERJOIN, CROSSJOIN, STRAIGHTJOIN, LEFTJOIN, LEFTOUTERJOIN, NATURALJOIN, NATURALLEFTJOIN, NATURALLEFTOUTERJOIN, RIGHTJOIN, RIGHTOUTERJOIN, NATURALRIGHTJOIN, NATURALRIGHTOUTERJOIN, FULLJOIN, FULLOUTERJOIN, NATURALFULLJOIN, NATURALFULLOUTERJOIN, INNERJOINOn, LEFTJOINOn, LEFTOUTERJOINOn, RIGHTJOINOn, RIGHTOUTERJOINOn, FULLJOINOn, FULLOUTERJOINOn, INNERJOINUsing, LEFTJOINUsing, LEFTOUTERJOINUsing, RIGHTJOINUsing, RIGHTOUTERJOINUsing, FULLJOINUsing, FULLOUTERJOINUsing.

How can I join a table with itself?

Use Alias from SQLBuilder. Example:

from sqlobject.sqlbuilder import Alias
alias = Alias(MyTable, "my_table_alias")
MyTable.select(MyTable.q.name == alias.q.value)

will generate the query:

SELECT my_table.* FROM my_table, my_table AS my_table_alias
WHERE my_table.name = my_table_alias.value;

Can I use a JOIN() with aliases?

Sure! That's a situation the JOINs and aliases were primary developed for. Code:

from sqlobject.sqlbuilder import LEFTJOINOn, Alias
alias = Alias(OtherTable, "other_table_alias")
MyTable.select(MyTable.q.name == OtherTable.q.value,
    join=LEFTJOINOn(MyTable, alias, MyTable.col1 == alias.q.col2))

will result in the query:

SELECT my_table.* FROM other_table,
    my_table LEFT JOIN other_table AS other_table_alias
WHERE my_table.name == other_table.value AND
    my_table.col1 = other_table_alias.col2.

Subqueries (subselects)

You can run queries with subqueries (subselects) on those DBMS that can do subqueries (MySQL supports subqueries from version 4.1).

Use corresponding classes and functions from SQLBuilder:

from sqlobject.sqlbuilder import EXISTS, Select
select = Test1.select(EXISTS(Select(Test2.q.col2, where=(Outer(Test1).q.col1 == Test2.q.col2))))

generates the query:

SELECT test1.id, test1.col1 FROM test1 WHERE
EXISTS (SELECT test2.col2 FROM test2 WHERE (test1.col1 = test2.col2))

Note the usage of Outer - it is a helper to allow referring to a table in the outer query.

Select() is used instead of .select() because you need to control what columns the inner query returns.

Available queries are IN(), NOTIN(), EXISTS(), NOTEXISTS(), SOME(), ANY() and ALL(). The last 3 are used with comparison operators, like this: somevalue = ANY(Select(...)).

Utilities

Some useful utility functions are included with SQLObject. For more information see their module docstrings.

SQLBuilder

For more information on SQLBuilder, read the SQLBuilder Documentation.

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.styles.MixedCaseUnderscoreStyle.html0000644000175000017500000001750212754657336027011 0ustar phdphd00000000000000

MixedCaseUnderscoreStyle

This is the default style. Python attributes use mixedCase, while database columns use underscore_separated.

The MixedCaseUnderscoreStyle class is accessible via the sqlobject.styles module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, pythonAttrToDBColumn=None, dbColumnToPythonAttr=None, pythonClassToDBTable=None, dbTableToPythonClass=None, idForTable=None, longID=False) ...

f idForTable(self, table) ...

f pythonClassToAttr(self, className) ...

f instanceAttrToIDAttr(self, attr) ...

f instanceIDAttrToAttr(self, attr) ...

f pythonAttrToDBColumn(self, attr) ...

f dbColumnToPythonAttr(self, col) ...

f pythonClassToDBTable(self, className) ...

f dbTableToPythonClass(self, table) ...

f pythonClassToDBTableReference(self, className) ...

f tableReference(self, table) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.styles.Style.html0000644000175000017500000001623612754657335023176 0ustar phdphd00000000000000

Style

The base Style class, and also the simplest implementation. No translation occurs -- column names and attribute names match, as do class names and table names (when using auto class or schema generation).

The Style class is accessible via the sqlobject.styles module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, pythonAttrToDBColumn=None, dbColumnToPythonAttr=None, pythonClassToDBTable=None, dbTableToPythonClass=None, idForTable=None, longID=False) ...

f pythonAttrToDBColumn(self, attr) ...

f dbColumnToPythonAttr(self, col) ...

f pythonClassToDBTable(self, className) ...

f dbTableToPythonClass(self, table) ...

f idForTable(self, table) ...

f pythonClassToAttr(self, className) ...

f instanceAttrToIDAttr(self, attr) ...

f instanceIDAttrToAttr(self, attr) ...

f tableReference(self, table) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.include.hashcol.html0000644000175000017500000000470312754657317023773 0ustar phdphd00000000000000

hashcol

The hashcol module is accessible via the sqlobject.include module.

Attributes

a __package__

'sqlobject.include'

Classes

C HashCol(...) ...

End-user HashCol class. May be instantiated with 'hashMethod', a function which returns the string hash of any other string (i.e. basestring).

This class contains 6 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOIntCol.html0000644000175000017500000002414512754657346022762 0ustar phdphd00000000000000

SOIntCol

The SOIntCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

f addSQLAttrs(self, str) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.styles.MixedCaseStyle.html0000644000175000017500000001632612754657336024762 0ustar phdphd00000000000000

MixedCaseStyle

This style leaves columns as mixed-case, and uses long ID names (like ProductID instead of simply id).

The MixedCaseStyle class is accessible via the sqlobject.styles module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, pythonAttrToDBColumn=None, dbColumnToPythonAttr=None, pythonClassToDBTable=None, dbTableToPythonClass=None, idForTable=None, longID=False) ...

f pythonClassToDBTable(self, className) ...

f idForTable(self, table) ...

f pythonClassToAttr(self, className) ...

f instanceAttrToIDAttr(self, attr) ...

f instanceIDAttrToAttr(self, attr) ...

f pythonAttrToDBColumn(self, attr) ...

f dbColumnToPythonAttr(self, col) ...

f dbTableToPythonClass(self, table) ...

f tableReference(self, table) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLModulo.html0000644000175000017500000004120712754657327024535 0ustar phdphd00000000000000

SQLModulo

The SQLModulo class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f components(self) ...

f execute(self, executor) ...

f __init__(self, expr1, expr2) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOUnicodeCol.html0000644000175000017500000002345612754657347023623 0ustar phdphd00000000000000

SOUnicodeCol

The SOUnicodeCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.DuplicateEntryError.html0000644000175000017500000001343212754657322026332 0ustar phdphd00000000000000

DuplicateEntryError

The DuplicateEntryError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/pudge.css0000711000175000017500000000206412754657230016373 0ustar phdphd00000000000000/* Layout ----------------------------------- */ @import url("rst.css"); /* Pudge Elements ----------------------------------- */ .note { font-size: 90% } h4.pudge-member-name { font-size: 110%; margin-bottom: 0; } h4.pudge-member-name a.obj-link { font-weight: bold; text-decoration: none; } h4.pudge-member-name .prefix { font-style: oblique; padding-right: 6px; font-weight: bold; color: #c9c; } h1.pudge-member-page-heading { font-size: 250%; } h4.pudge-member-page-subheading { font-size: 150%; } h4.pudge-member-page-subheading p { display: inline; } div.pudge-member { margin-top: 1.5em; margin-bottom: 1.5em; } ul.pudge-module-index { margin-left: 0; padding-left: 0; } ul.pudge-module-index ul { padding-left: 1.5em; margin-left: 0; } ul.pudge-module-index li { list-style-type: none; } ul.pudge-module-index .prefix { font-style: oblique; padding-right: 6px; font-size: 90%; font-weight: bold; color: purple; } ul.pudge-module-index a { text-decoration: none; } div.pudge-section { margin-left: 2em; }SQLObject-3.1.0/docs/html/class-sqlobject.col.BoolCol.html0000644000175000017500000000747312754657351022662 0ustar phdphd00000000000000

BoolCol

The BoolCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.rdbhost.rdbhostconnection.RdbhostConnection.html0000644000175000017500000000625612754657323031367 0ustar phdphd00000000000000

RdbhostConnection

The RdbhostConnection class is accessible via the sqlobject.rdbhost.rdbhostconnection module.

Attributes

a supportTransactions

False

a schemes

['rdbhost']

a dbName

'rdbhost'

Methods

f __init__(self, dsn=None, host=None, port=None, db=None, user=None, password=None, unicodeCols=False, driver='rdbhost', **kw) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOBoolCol.html0000644000175000017500000002450412754657350023115 0ustar phdphd00000000000000

SOBoolCol

The SOBoolCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, name, soClass, creationOrder, dbName=None, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, notNone=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, unique=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f autoConstraints(self) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Table.html0000644000175000017500000004074012754657333023743 0ustar phdphd00000000000000

Table

The Table class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, tableName) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLJoinUsing.html0000644000175000017500000004072512754657332025203 0ustar phdphd00000000000000

SQLJoinUsing

Conditional JOIN USING

The SQLJoinUsing class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __sqlrepr__(self, db) ...

f __init__(self, table1, table2, op, using_columns) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.util.threadinglocal-index.html0000644000175000017500000000454412754657321025767 0ustar phdphd00000000000000 Index of sqlobject.util.threadinglocal module

Index of the threadinglocal module

SQLObject-3.1.0/docs/html/module-sqlobject.mssql.mssqlconnection.html0000644000175000017500000000452112754657324025301 0ustar phdphd00000000000000

mssqlconnection

The mssqlconnection module is accessible via the sqlobject.mssql module.

Attributes

a __package__

'sqlobject.mssql'

Classes

C MSSQLConnection(...) ...

This class contains 24 members.

See the source for more information.

SQLObject-3.1.0/docs/html/FAQ.html0000644000175000017500000007017112754657232016065 0ustar phdphd00000000000000 SQLObject FAQ

SQLObject FAQ

SQLExpression

In SomeTable.select(SomeTable.q.Foo > 30) why doesn't the inner parameter, SomeTable.q.Foo > 30, get evaluated to some boolean value?

q is an object that returns special attributes of type sqlbuilder.SQLExpression. SQLExpression is a special class that overrides almost all Python magic methods and upon any operation instead of evaluating it constructs another instance of SQLExpression that remembers what operation it has to do. Similar to a symbolic algebra. Example:

SQLExpression("foo") > 30

produces SQLExpression("foo", ">", 30) (well, it really produces SQLExpression(SQLExpression("foo")...))

How does the select(...) method know what to do?

In short, select() recursively evaluates the top-most SQLExpression to a string:

SQLExpression("foo", ">", 30) => "foo > 30"

and passes the result as a string to the SQL backend.

The longer but more detailed and correct explanation is that select() produces an instance of SelectResults class that upon being iterated over produces an instance of Iteration class that upon calling its next() method (it is iterator!) construct the SQL query string, passes it to the backend, fetches the results, wraps every row as SQLObject instance and passes them back to the user.

For the details of the implementation see sqlobject/main.py for SQLObject, sqlobject/sqlbuilder.py for SQLExpression, sqlobject/dbconnection.py for DBConnection class (that constructs the query strings) and Iteration class, and different subdirectories of sqlobject for concrete implementations of connection classes - different backends require different query strings.

Why there is no __len__?

There are reasons why there is no __len__ method, though many people think having those make them feel more integrated into Python.

One is that len(foo) is expected to be fast, but issuing a COUNT query can be slow. Worse, often this causes the database to do essentially redundant work when the actual query is performed (generally taking the len of a sequence is followed by accessing items from that sequence).

Another is that list(foo) implicitly tries to do a len first, as an optimization (because len is expected to be cheap -- see previous point). Worse, it swallows all exceptions that occur during that call to __len__, so if it fails (e.g. there's a typo somewhere in the query), the original cause is silently discarded, and instead you're left with mysterious errors like "current transaction is aborted, commands ignored until end of transaction block" for no apparent reason.

How can I do a LEFT JOIN?

The short: you can't. You don't need to. That's a relational way of thinking, not an object way of thinking. But it's okay! It's not hard to do the same thing, even if it's not with the same query.

For these examples, imagine you have a bunch of customers, with contacts. Not all customers have a contact, some have several. The left join would look like:

SELECT customer.id, customer.first_name, customer.last_name,
       contact.id, contact.address
FROM customer
LEFT JOIN contact ON contact.customer_id = customer.id

Simple

for customer in Customer.select():
    print customer.firstName, customer.lastName
    for contact in customer.contacts:
        print '   ', contact.phoneNumber

The effect is the same as the left join -- you get all the customers, and you get all their contacts. The problem, however, is that you will be executing more queries -- a query for each customer to fetch the contacts -- where with the left join you'd only do one query. The actual amount of information returned from the database will be the same. There's a good chance that this won't be significantly slower. I'd advise doing it this way unless you hit an actual performance problem.

Efficient

Lets say you really don't want to do all those queries. Okay, fine:

custContacts = {}
for contact in Contact.select():
    custContacts.setdefault(contact.customerID, []).append(contact)
for customer in Customer.select():
    print customer.firstName, customer.lastName
    for contact in custContacts.get(customer.id, []):
        print '   ', contact.phoneNumber

This way there will only be at most two queries. It's a little more crude, but this is an optimization, and optimizations often look less than pretty.

But, say you don't want to get everyone, just some group of people (presumably a large enough group that you still need this optimization):

query = Customer.q.firstName.startswith('J')
custContacts = {}
for contact in Contact.select(AND(Contact.q.customerID == Customer.q.id,
                                  query)):
    custContacts.setdefault(contact.customerID, []).append(contact)
for customer in Customer.select(query):
    print customer.firstName, customer.lastName
    for contact in custContacts.get(customer.id, []):
        print '   ', contact.phoneNumber

SQL-wise

Use LEFTJOIN() from SQLBuilder.

How can I define my own intermediate table in my Many-to-Many relationship?

Note

In User and Role, SQLRelatedJoin is used with createRelatedTable=False so the intermediate table is not created automatically. We also set the intermediate table name with intermediateTable='user_roles'. UserRoles is the definition of our intermediate table. UserRoles creates a unique index to make sure we don't have duplicate data in the database. We also added an extra field called active which has a boolean value. The active column might be used to activate/deactivate a given role for a user in this example. Another common field to add in this an intermediate table might be a sort field. If you want to get a list of rows from the intermediate table directly add a MultipleJoin to User or Role class.

We'll expand on the User and Role example and define our own UserRoles class which will be the intermediate table for the User and Role Many-to-Many relationship.

Example:

>>> class User(SQLObject):
...     class sqlmeta:
...         table = "user_table"
...     username = StringCol(alternateID=True, length=20)
...     roles = SQLRelatedJoin('Role',
...         intermediateTable='user_roles',
...         createRelatedTable=False)

>>> class Role(SQLObject):
...     name = StringCol(alternateID=True, length=20)
...     users = SQLRelatedJoin('User',
...         intermediateTable='user_roles',
...         createRelatedTable=False)

>>> class UserRoles(SQLObject):
...     class sqlmeta:
...         table = "user_roles"
...     user = ForeignKey('User', notNull=True, cascade=True)
...     role = ForeignKey('Role', notNull=True, cascade=True)
...     active = BoolCol(notNull=True, default=False)
...     unique = index.DatabaseIndex(user, role, unique=True)

How Does Inheritance Work?

SQLObject is not intended to represent every Python inheritance structure in an RDBMS -- rather it is intended to represent RDBMS structures as Python objects. So lots of things you can do in Python you can't do with SQLObject classes. However, some form of inheritance is possible.

One way of using this is to create local conventions. Perhaps:

class SiteSQLObject(SQLObject):
    _connection = DBConnection.MySQLConnection(user='test', db='test')
    _style = MixedCaseStyle()

    # And maybe you want a list of the columns, to autogenerate
    # forms from:
    def columns(self):
        return [col.name for col in self._columns]

Since SQLObject doesn't have a firm introspection mechanism (at least not yet) the example shows the beginnings of a bit of ad hoc introspection (in this case exposing the _columns attribute in a more pleasing/public interface).

However, this doesn't relate to database inheritance at all, since we didn't define any columns. What if we do?

class Person(SQLObject):
    firstName = StringCol()
    lastName = StringCol()

class Employee(Person):
    position = StringCol()

Unfortunately, the resultant schema probably doesn't look like what you might have wanted:

CREATE TABLE person (
    id INT PRIMARY KEY,
    first_name TEXT,
    last_name TEXT
);

CREATE TABLE employee (
    id INT PRIMARY KEY
    first_name TEXT,
    last_name TEXT,
    position TEXT
)

All the columns from person are just repeated in the employee table. What's more, an ID for a Person is distinct from an ID for an employee, so for instance you must choose ForeignKey("Person") or ForeignKey("Employee"), you can't have a foreign key that sometimes refers to one, and sometimes refers to the other.

Altogether, not very useful. You probably want a person table, and then an employee table with a one-to-one relation between the two. Of course, you can have that, just create the appropriate classes/tables -- but it will appear as two distinct classes, and you'd have to do something like Person(1).employee.position. Of course, you can always create the necessary shortcuts, like:

class Person(SQLObject):
    firstName = StringCol()
    lastName = StringCol()

    def _get_employee(self):
        value = Employee.selectBy(person=self)
        if value:
            return value[0]
        else:
            raise AttributeError, '%r is not an employee' % self
    def _get_isEmployee(self):
        value = Employee.selectBy(person=self)
        # turn into a bool:
        return not not value
    def _set_isEmployee(self, value):
        if value:
            # Make sure we are an employee...
            if not self.isEmployee:
                Empoyee.new(person=self, position=None)
        else:
            if self.isEmployee:
                self.employee.destroySelf()
    def _get_position(self):
        return self.employee.position
    def _set_position(self, value):
        self.employee.position = value

class Employee(SQLObject):
    person = ForeignKey('Person')
    position = StringCol()

There is also another kind of inheritance. See Inheritance.html

Composite/Compound Attributes

A composite attribute is an attribute formed from two columns. For example:

CREATE TABLE invoice_item (
    id INT PRIMARY KEY,
    amount NUMERIC(10, 2),
    currency CHAR(3)
);

Now, you'll probably want to deal with one amount/currency value, instead of two columns. SQLObject doesn't directly support this, but it's easy (and encouraged) to do it on your own:

class InvoiceItem(SQLObject):
    amount = Currency()
    currency = StringChar(length=3)

    def _get_price(self):
        return Price(self.amount, self.currency)
    def _set_price(self, price):
        self.amount = price.amount
        self.currency = price.currency

class Price(object):
    def __init__(self, amount, currency):
        self._amount = amount
        self._currency = currency

    def _get_amount(self):
        return self._amount
    amount = property(_get_amount)

    def _get_currency(self):
        return self._currency
    currency = property(_get_currency)

    def __repr__(self):
        return '<Price: %s %s>' % (self.amount, self.currency)

You'll note we go to some trouble to make sure that Price is an immutable object. This is important, because if Price wasn't and someone changed an attribute, the containing InvoiceItem instance wouldn't detect the change and update the database. (Also, since Price doesn't subclass SQLObject, we have to be explicit about creating properties) Some people refer to this sort of class as a Value Object, that can be used similar to how an integer or string is used.

You could also use a mutable composite class:

class Address(SQLObject):
    street = StringCol()
    city = StringCol()
    state = StringCol(length=2)

    latitude = FloatCol()
    longitude = FloatCol()

    def _init(self, id):
        SQLObject._init(self, id)
        self._coords = SOCoords(self)

    def _get_coords(self):
        return self._coords

class SOCoords(object):
    def __init__(self, so):
        self._so = so

    def _get_latitude(self):
        return self._so.latitude
    def _set_latitude(self, value):
        self._so.latitude = value
    latitude = property(_get_latitude, set_latitude)

    def _get_longitude(self):
        return self._so.longitude
    def _set_longitude(self, value):
        self._so.longitude = value
    longitude = property(_get_longitude, set_longitude)

Pretty much a proxy, really, but SOCoords could contain other logic, could interact with non-SQLObject-based latitude/longitude values, or could be used among several objects that have latitude/longitude columns.

Non-Integer IDs

Yes, you can use non-integer IDs.

If you use non-integer IDs, you will not be able to use automatic CREATE TABLE generation (i.e., createTable); SQLObject can create tables with int or str IDs. You also will have to give your own ID values when creating an object, like:

color = Something(id="blue", r=0, b=100, g=0)

IDs are, and always will in future versions, be considered immutable. Right now that is not enforced; you can assign to the id attribute. But if you do you'll just mess everything up. This will probably be taken away sometime to avoid possibly confusing bugs (actually, assigning to id is almost certain to cause confusing bugs).

If you are concerned about enforcing the type of IDs (which can be a problem even with integer IDs) you may want to do this:

def Color(SQLObject):
    def _init(self, id, connection=None):
        id = str(id)
        SQLObject._init(self, id, connection)

Instead of str() you may use int() or whatever else you want. This will be resolved in a future version when ID column types can be declared like other columns.

Additionally you can set idType=str in you SQLObject class.

Binary Values

Binary values can be difficult to store in databases, as SQL doesn't have a widely-implemented way to express binaries as literals, and there's differing support in database.

The module sqlobject.col defines validators and column classes that to some extent support binary values. There is BLOBCol that extends StringCol and allow to store binary values; currently it works only with PostgreSQL and MySQL. PickleCol extends BLOBCol and allows to store any object in the column; the column, naturally, pickles the object upon assignment and unpickles it upon retrieving the data from the DB.

Another possible way to keep binary data in a database is by using encoding. Base 64 is a good encoding, reasonably compact but also safe. As an example, imagine you want to store images in the database:

class Image(SQLObject):

    data = StringCol()
    height = IntCol()
    width = IntCol()

    def _set_data(self, value):
        self._SO_set_data(value.encode('base64'))

    def _get_data(self, value):
        return self._SO_get_data().decode('base64')

Reloading Modules

If you've tried to reload a module that defines SQLObject subclasses, you've probably encountered various odd errors. The short answer: you can't reload these modules.

The long answer: reloading modules in Python doesn't work very well. Reloading actually means re-running the module. Every class statement creates a class -- but your old classes don't disappear. When you reload a module, new classes are created, and they take over the names in the module.

SQLObject, however, doesn't search the names in a module to find a class. When you say ForeignKey('SomeClass'), SQLObject looks for any SQLObject subclass anywhere with the name SomeClass. This is to avoid problems with circular imports and circular dependencies, as tables have forward- and back-references, and other circular dependencies. SQLObject resolves these dependencies lazily.

But when you reload a module, suddenly there will be two SQLObject classes in the process with the same name. SQLObject doesn't know that one of them is obsolete. And even if it did, it doesn't know every other place in the system that has a reference to that obsolete class.

For this reason and several others, reloading modules is highly error-prone and difficult to support.

Python Keywords

If you have a table column that is a Python keyword, you should know that the Python attribute doesn't have to match the name of the column. See Irregular Naming in the documentation.

Lazy Updates and Insert

Lazy updates allow you to defer sending UPDATES until you synchronize the object. However, there is no way to do a lazy insert; as soon as you create an instance the INSERT is executed.

The reason for this limit is that each object needs a database ID, and in many databases you cannot attain an ID until you create a row.

Mutually referencing tables

How can I create mutually referencing tables? For the code:

class Person(SQLObject):
    role = ForeignKey("Role")

class Role(SQLObject):
    person = ForeignKey("Person")

Person.createTable()
Role.createTable()

Postgres raises ProgrammingError: ERROR: relation "role" does not exist.

The correct way is to delay constraints creation until all tables are created:

class Person(SQLObject):
    role = ForeignKey("Role")

class Role(SQLObject):
    person = ForeignKey("Person")

constraints = Person.createTable(applyConstraints=False)
constraints += Role.createTable(applyConstraints=False)

for constraint in constraints:
    connection.query(constraint)

What about GROUP BY, UNION, etc?

In short - not every query can be represented in SQLObject. SQLOBject's objects are instances of "table" clasess:

class MyTable(SQLObject):
    ...

my_table_row = MyTable.get(id)

Now my_table_row is an instance of MyTable class and represents a row in the my_table table. But for a statement with GROUP BY like this:

SELECT my_column, COUNT(*) FROM my_table GROUP BY my_column;

there is no table, there is no corresponding "table" class, and SQLObject cannot return a list of meaningful objects.

You can use a lower-level machinery available in SQLBuilder.

How to do mass-insertion?

Mass-insertion using high-level API in SQLObject is slow. There are many reasons for that. First, on creation SQLObject instances pass all values through validators/converters which is convenient but takes time. Second, after an INSERT query SQLObject executes a SELECT query to get back autogenerated values (id and timestamps). Third, there is caching and cache maintaining. Most of this is unnecessary for mass-insertion, hence high-level API is unsuitable.

Less convenient (no validators) but much faster API is Insert from SQLBuilder.

How can I specify the MySQL engine to use, or tweak other SQL-engine specific features?

You can ALTER the table just after creation using the sqlmeta attribute createSQL, for example:

class SomeObject(SQLObject):
    class sqlmeta:
        createSQL = { 'mysql' : 'ALTER TABLE some_object ENGINE InnoDB' }
    # your columns here

Maybe you want to specify the charset too? No problem:

class SomeObject(SQLObject):
    class sqlmeta:
        createSQL = { 'mysql' : [
            'ALTER TABLE some_object ENGINE InnoDB',
            '''ALTER TABLE some_object CHARACTER SET utf8
                COLLATE utf8_estonian_ci''']
            }
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.col.SOCol.html0000644000175000017500000002450612754657347022311 0ustar phdphd00000000000000

SOCol

The SOCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, name, soClass, creationOrder, dbName=None, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, notNone=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, unique=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None) ...

f createValidators(self) ...

Create a list of validators for the column.

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.BigIntCol.html0000644000175000017500000000751312754657346023142 0ustar phdphd00000000000000

BigIntCol

The BigIntCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.InternalError.html0000644000175000017500000001332212754657322025150 0ustar phdphd00000000000000

InternalError

The InternalError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.versioning.Versioning.html0000644000175000017500000001250712754657322025052 0ustar phdphd00000000000000

Versioning

The Versioning class is accessible via the sqlobject.versioning module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, extraCols=None) ...

f __addtoclass__(self, soClass, name) ...

f createVersionTable(self, cls, conn) ...

f createTable(self, soClass, connection, extra_sql, post_funcs) ...

f rowUpdate(self, instance, kwargs) ...

f __get__(self, obj, type=None) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandStatus.html0000644000175000017500000003714512754657314026363 0ustar phdphd00000000000000

CommandStatus

The CommandStatus class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

'This command checks the SQLObject definition and checks if the tables in the database match.  It can always test for missing tables, and on some databases can test for the existance of other tables.  Column types are not currently checked.'

a parser

<optparse.OptionParser instance at 0xb64e702c>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'status'

a summary

'Show status of classes vs. database'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f print_class(self, soClass) ...

f command(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.DBAPI.html0000644000175000017500000004063112754657340024027 0ustar phdphd00000000000000

DBAPI

Subclass must define a makeConnection() method, which returns a newly-created connection object.

The DBAPI class is accessible via the sqlobject.dbconnection module.

queryInsertID must also be defined.

Attributes

a dbName

None

Methods

f oldUri(self) ...

f uri(self) ...

f connectionFromOldURI(cls, uri) ...

f connectionFromURI(cls, uri) ...

f soClassAdded(self, soClass) ...

This is called for each new class; we use this opportunity to create an instance method that is bound to the class and this connection.

f expireAll(self) ...

Expire all instances of objects for this connection.

f __init__(self, **kw) ...

f getConnection(self) ...

f releaseConnection(self, conn, explicit=False) ...

f printDebug(self, conn, s, name, type='query') ...

f query(self, s) ...

f queryAll(self, s) ...

f queryAllDescription(self, s) ...

f queryOne(self, s) ...

f transaction(self) ...

f queryInsertID(self, soInstance, id, names, values) ...

f iterSelect(self, select) ...

f accumulateSelect(self, select, *expressions) ...

Apply an accumulate function(s) (SUM, COUNT, MIN, AVG, MAX, etc...) to the select object.

f queryForSelect(self, select) ...

f createIndexSQL(self, soClass, index) ...

f createTable(self, soClass) ...

f createReferenceConstraints(self, soClass) ...

f createSQL(self, soClass) ...

f createTableSQL(self, soClass) ...

f createColumns(self, soClass) ...

f createReferenceConstraint(self, soClass, col) ...

f createColumn(self, soClass, col) ...

f dropTable(self, tableName, cascade=False) ...

f clearTable(self, tableName) ...

f createBinary(self, value) ...

Create a binary object wrapper for the given database.

f sqlrepr(self, v) ...

f __del__(self) ...

f close(self) ...

f createEmptyDatabase(self) ...

Create an empty database.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOBLOBCol.html0000644000175000017500000002336612754657347022753 0ustar phdphd00000000000000

SOBLOBCol

The SOBLOBCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f autoConstraints(self) ...

f __init__(self, **kw) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.joins.SingleJoin.html0000644000175000017500000001032712754657353023731 0ustar phdphd00000000000000

SingleJoin

The SingleJoin class is accessible via the sqlobject.joins module.

Attributes

a joinMethodName

<property object at 0xb65c6c0c>

a name

<property object at 0xb65c6c0c>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, otherClass=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SODateTimeCol.html0000644000175000017500000002426112754657352023720 0ustar phdphd00000000000000

SODateTimeCol

The SODateTimeCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

a datetimeFormat

'%Y-%m-%d %H:%M:%S.%f'

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.manager.command-index.html0000644000175000017500000011366512754657312025067 0ustar phdphd00000000000000 Index of sqlobject.manager.command module

Index of the command module

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandList.html0000644000175000017500000003557112754657312026012 0ustar phdphd00000000000000

CommandList

The CommandList class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

''

a parser

<optparse.OptionParser instance at 0xb64cf20c>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'list'

a summary

'Show all SQLObject classes found'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.JSONCol.html0000644000175000017500000000750212754657351022531 0ustar phdphd00000000000000

JSONCol

The JSONCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/News.html0000644000175000017500000001250412754657232016366 0ustar phdphd00000000000000 News

News

SQLObject 3.1.0

Released 16 Aug 2016.

Features

  • Add UuidCol.
  • Add JsonbCol. Only for PostgreSQL. Requires psycopg2 >= 2.5.4 and PostgreSQL >= 9.2.
  • Add JSONCol, a universal json column.
  • For Python >= 3.4 minimal FormEncode version is now 1.3.1.
  • If mxDateTime is in use, convert timedelta (returned by MySQL) to mxDateTime.Time.

Documentation

  • Developer's Guide extended to explain SQLObject architecture and how to create a new column type.
  • Fix URLs that can be found; remove missing links.
  • Rename reStructuredText files from *.txt to *.rst.

Source code

Tests

  • Tests are now run at Circle CI.
  • Use pytest-cov for test coverage. Report test coverage via coveralls.io and codecov.io.
  • Install mxDateTime to run date/time tests with it.

SQLObject 3.0.0

Released 1 Jun 2016.

Features

  • Support for Python 2 and Python 3 with one codebase! (Python version >= 3.4 currently required.)

Minor features

  • PyDispatcher (>=2.0.4) was made an external dependency.

Development

  • Source code was made flake8-clean.

Documentation

Older news

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.col.SOCurrencyCol.html0000644000175000017500000002352212754657346024020 0ustar phdphd00000000000000

SOCurrencyCol

The SOCurrencyCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f createValidators(self) ...

f __init__(self, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.include.tests.test_hashcol.HashTest.html0000644000175000017500000002272112754657317027535 0ustar phdphd00000000000000

HashTest

The HashTest class is accessible via the sqlobject.include.tests.test_hashcol module.

Attributes

a childName

None

a col2

<property object at 0xb669cedc>

a col1

<property object at 0xb669cf04>

a count

<property object at 0xb669ceb4>

a j

hash_test

a q

hash_test

Methods

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __classinit__(cls, new_attrs) ...

f __init__(self, **kw) ...

f __sqlrepr__(self, db) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __getstate__(self) ...

f __setstate__(self, d) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.RowDestroySignal.html0000644000175000017500000001017112754657341025323 0ustar phdphd00000000000000

RowDestroySignal

Called before an instance is deleted. Sender is the instance's class. Arguments are (instance, post_funcs).

The RowDestroySignal class is accessible via the sqlobject.events module.

post_funcs is a list of callbacks, intended to have functions appended to it, and are called with arguments (instance). If any of the post_funcs raises an exception, the deletion is only affected if this will prevent a commit.

You cannot cancel the delete, but you can raise an exception (which will probably cancel the delete, but also cause an uncaught exception if not expected).

Note: this is not called when an instance is destroyed through garbage collection.

@@: Should this allow instance to be a primary key, so that a row can be deleted without first fetching it?

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.ImportProxy.html0000644000175000017500000004076212754657330025231 0ustar phdphd00000000000000

ImportProxy

Class to be used in column definitions that rely on other tables that might not yet be in a classregistry.

The ImportProxy class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, clsName, registry=None) ...

f __nonzero__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.maxdb.maxdbconnection.IncorrectIDStyleError.html0000644000175000017500000001365512754657343031221 0ustar phdphd00000000000000

IncorrectIDStyleError

The IncorrectIDStyleError class is accessible via the sqlobject.maxdb.maxdbconnection module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.Iteration.html0000644000175000017500000001136512754657340025150 0ustar phdphd00000000000000

Iteration

The Iteration class is accessible via the sqlobject.dbconnection module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, dbconn, rawconn, select, keepConnection=False) ...

f __iter__(self) ...

f __next__(self) ...

f next(self) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sybase-index.html0000644000175000017500000002205212754657340023314 0ustar phdphd00000000000000 Index of sqlobject.sybase module

Index of the sybase module

SQLObject-3.1.0/docs/html/module-sqlobject.util.csvimport-index.html0000644000175000017500000000764112754657321025036 0ustar phdphd00000000000000 Index of sqlobject.util.csvimport module

Index of the csvimport module

  • m sqlobject.util.csvimport ... - Import from a CSV file or directory of files.
    • a __package__ ...
    • f create_data ... - Create the data, which is the return value from load_csv(). Classes will be resolved with the callable class_getter; or if class_getter is a module then the class names will be attributes of that.
    • f load_csv ... - Loads the CSV file, returning a list of dictionaries with types coerced.
    • f load_csv_from_directory ... - Load the data from all the files in a directory. Filenames indicate the class, with general.csv for data not associated with a class. Return data just like load_csv does.
SQLObject-3.1.0/docs/html/module-sqlobject.postgres-index.html0000644000175000017500000002401512754657317023701 0ustar phdphd00000000000000 Index of sqlobject.postgres module

Index of the postgres module

SQLObject-3.1.0/docs/html/module-sqlobject.versioning.html0000644000175000017500000000641012754657321023103 0ustar phdphd00000000000000

versioning

The versioning module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.versioning'

Functions

f getColumns(columns, cls) ...

Classes

C Version(...) ...

This class contains 21 members.

C Versioning(...) ...

This class contains 9 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.TimeCol.html0000644000175000017500000000750212754657350022655 0ustar phdphd00000000000000

TimeCol

The TimeCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.ConstantSpace.html0000644000175000017500000000174412754657327025465 0ustar phdphd00000000000000

ConstantSpace

The ConstantSpace class is accessible via the sqlobject.sqlbuilder module.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.ClassCreateSignal.html0000644000175000017500000001051012754657342025371 0ustar phdphd00000000000000

ClassCreateSignal

Signal raised after class creation. The sender is the superclass (in case of multiple superclasses, the first superclass). The arguments are (new_class_name, bases, new_attrs, post_funcs, early_funcs). new_attrs is a dictionary and may be modified (but new_class_name and bases are immutable). post_funcs is an initially-empty list that can have callbacks appended to it.

The ClassCreateSignal class is accessible via the sqlobject.events module.

Note: at the time this event is called, the new class has not yet been created. The functions in post_funcs will be called after the class is created, with the single arguments of (new_class). Also, early_funcs will be called at the soonest possible time after class creation (post_funcs is called after the class's __classinit__).

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/download.html0000644000175000017500000001065112754657232017262 0ustar phdphd00000000000000 Download SQLObject

Download SQLObject

The latest releases are always available on the Python Package Index, and is installable with pip or easy_install.

You can install the latest release with:

pip install -U SQLObject

or:

easy_install -U SQLObject

You can install the latest version of SQLObject with:

easy_install SQLObject==dev

You can install the latest bug fixing branch with:

easy_install SQLObject==bugfix

If you want to require a specific revision (because, for instance, you need a bugfix that hasn't appeared in a release), you can put this in your setuptools using setup.py file:

setup(...
  install_requires=["SQLObject==bugfix,>=0.7.1dev-r1485"],
)

This says that you need revision 1485 or higher. But it also says that you can aquire the "bugfix" version to try to get that. In fact, when you install SQLObject==bugfix you will be installing a specific version, and "bugfix" is just a kind of label for a way of acquiring the version (it points to a branch in the repository).

Repositories

The SQLObject git repositories are located at https://sourceforge.net/p/sqlobject/_list/git and https://github.com/sqlobject

Before switching to git development was performed at the Subversion repository that is still located at http://svn.colorstudy.com/SQLObject

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/SelectResults.html0000644000175000017500000003364612754657232020265 0ustar phdphd00000000000000 SelectResults: Using Queries

SelectResults: Using Queries

Overview

SelectResults are returned from .select and .selectBy methods on SQLObject classes, and from SQLMultipleJoin, and SQLRelatedJoin accessors on SQLObject instances.

Select results are generators, which are lazily evaluated. The SQL is only executed when you iterate over the select results, fetching rows one at a time. This way you can iterate over large results without keeping the entire result set in memory. You can also do things like .reversed() without fetching and reversing the entire result -- instead, SQLObject can change the SQL that is sent so you get equivalent results.

Note

To retrieve the results all at once use the python idiom of calling list() on the generator to force execution and convert the results to a stored list.

You can also slice select results. This modifies the SQL query, so peeps[:10] will result in LIMIT 10 being added to the end of the SQL query. If the slice cannot be performed in the SQL (e.g., peeps[:-10]), then the select is executed, and the slice is performed on the list of results. This will generally only happen when you use negative indexes.

In certain cases, you may get a select result with an object in it more than once, e.g., in some joins. If you don't want this, you can add the keyword argument MyClass.select(..., distinct=True), which results in a SELECT DISTINCT call.

You can get the length of the result without fetching all the results by calling count on the result object, like MyClass.select().count(). A COUNT(*) query is used -- the actual objects are not fetched from the database. Together with slicing, this makes batched queries easy to write:

start = 20
size = 10
query = Table.select()
results = query[start:start+size]
total = query.count()
print "Showing page %i of %i" % (start/size + 1, total/size + 1)

Note

There are several factors when considering the efficiency of this kind of batching, and it depends very much how the batching is being used. Consider a web application where you are showing an average of 100 results, 10 at a time, and the results are ordered by the date they were added to the database. While slicing will keep the database from returning all the results (and so save some communication time), the database will still have to scan through the entire result set to sort the items (so it knows which the first ten are), and depending on your query may need to scan through the entire table (depending on your use of indexes). Indexes are probably the most important way to improve importance in a case like this, and you may find caching to be more effective than slicing.

In this case, caching would mean retrieving the complete results. You can use list(MyClass.select(...)) to do this. You can save these results for some limited period of time, as the user looks through the results page by page. This means the first page in a search result will be slightly more expensive, but all later pages will be very cheap.

Retrieval Methods

Iteration

As mentioned in the overview, the typical way to access the results is by treating it as a generator and iterating over it (in a loop, by converting to a list, etc).

getOne(default=optional)

In cases where your restrictions cause there to always be a single record in the result set, this method will return it or raise an exception: SQLObjectIntegrityError if more than one result is found, or SQLObjectNotFound if there are actually no results, unless you pass in a default like .getOne(None).

Cloning Methods

These methods return a modified copy of the SelectResult instance they are called on, so successive calls can chained, eg results = MyClass.selectBy(city='Boston').filter(MyClass.q.commute_distance>10).orderBy('vehicle_mileage') or used independently later on.

orderBy(column)

Takes a string column name (optionally prefixed with '-' for DESCending) or a SQLBuilder expression.

limit(num)

Only return first num many results. Equivalent to results[:num] slicing.

lazyColumns(v)

Only fetch the IDs for the results, the rest of the columns will be retrieved when attributes of the returned instances are accessed.

reversed()

Reverse-order. Alternative to calling orderBy with SQLBuilder.DESC or '-'.

distinct()

In SQL, SELECT DISTINCT, removing duplicate rows.

filter(expression)

Add additional expressions to restrict result set. Takes either a string static SQL expression valid in a WHERE clause, or a SQLBuilder expression. ANDed with any previous expressions.

Aggregate Methods

These return column values (strings, numbers, etc) not new SQLResults instances, by making the appropriate SQL query (the actual result rows are not retrieved). Any that take a column can also take a SQLBuilder column instance, e.g. MyClass.q.size.

count()

Returns the length of the result set, by a SQL SELECT COUNT(...) query.

sum(column)

The sum of values for column in the result set.

min(column)

The minimum value for column in the result set.

max(column)

The maximum value for column in the result set.

avg(column)

The average value for the column in the result set.

SQLObject-3.1.0/docs/html/module-sqlobject.constraints-index.html0000644000175000017500000001430012754657323024373 0ustar phdphd00000000000000 Index of sqlobject.constraints module

Index of the constraints module

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.SQLObjectVersionTable.html0000644000175000017500000002251312754657313027675 0ustar phdphd00000000000000

SQLObjectVersionTable

This table is used to store information about the database and its version (used with record and update commands).

The SQLObjectVersionTable class is accessible via the sqlobject.manager.command module.

Attributes

a version

<property object at 0xb64c50a4>

a childName

None

a updated

<property object at 0xb64c507c>

a j

sqlobject_db_version

a q

sqlobject_db_version

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __classinit__(cls, new_attrs) ...

f __init__(self, **kw) ...

f __sqlrepr__(self, db) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __getstate__(self) ...

f __setstate__(self, d) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.JsonbCol.html0000644000175000017500000000751212754657346023040 0ustar phdphd00000000000000

JsonbCol

The JsonbCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.PickleCol.html0000644000175000017500000000752212754657350023170 0ustar phdphd00000000000000

PickleCol

The PickleCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mysql-index.html0000644000175000017500000002374712754657315023211 0ustar phdphd00000000000000 Index of sqlobject.mysql module

Index of the mysql module

SQLObject-3.1.0/docs/html/links.html0000644000175000017500000001120112754657233016564 0ustar phdphd00000000000000 SQLObject Links

SQLObject Links

If you have a link you'd like added to this page, please submit a bug report with the link and title at bug tracker or send pull requests at GitHub).

Open Source Projects

  • TurboGears Web Framework: also integrates with SQLObject.
  • Catwalk is a web-based SQLObject browser and object editor (included in TurboGears).
  • Ultra Gleeper, a Recommendation Engine for Web Pages.
  • Guten; an application for browsing, reading, and managing books from Project Gutenberg.
  • My Newspaper, a personal RSS Aggregator and Reader.
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.ColumnAS.html0000644000175000017500000004134212754657326024376 0ustar phdphd00000000000000

ColumnAS

Just like SQLOp('AS', expr, name) except without the parentheses

The ColumnAS class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f components(self) ...

f execute(self, executor) ...

f __init__(self, expr, name) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.include-index.html0000644000175000017500000002300012754657316023446 0ustar phdphd00000000000000 Index of sqlobject.include module

Index of the include module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.NOTINSubquery.html0000644000175000017500000004142612754657327025350 0ustar phdphd00000000000000

NOTINSubquery

The NOTINSubquery class is accessible via the sqlobject.sqlbuilder module.

Attributes

a op

'NOT IN'

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, item, subquery) ...

f components(self) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.rdbhost.rdbhostconnection-index.html0000644000175000017500000000760312754657323027225 0ustar phdphd00000000000000 Index of sqlobject.rdbhost.rdbhostconnection module

Index of the rdbhostconnection module

SQLObject-3.1.0/docs/html/class-sqlobject.col.ForeignKey.html0000644000175000017500000000754312754657352023372 0ustar phdphd00000000000000

ForeignKey

The ForeignKey class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f withClass(self, soClass) ...

f __init__(self, foreignKey=None, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/Inheritance.html0000644000175000017500000003442612754657232017712 0ustar phdphd00000000000000

Author: Daniel Savard, XSOLI Inc.

Inheritance

Why

Imagine you have a list of persons, and every person plays a certain role. Some persons are students, some are professors, some are employees. Every role has different attributes. Students are known by their department and year. Professors have a department (some attributes are common for all or some roles), timetable and other attributes.

How does one implement this in SQLObject? Well, the obvious approach is to create a table Person with a column that describes or name the role, and a table for an every role. Then one must write code that interprets and dereferences the role column.

Well, the inheritance machinery described below does exactly this! Only it does it automagically and mostly transparent to the user.

First, you create a table Person. Nothing magical here:

class Person(SQLObject):
    name = StringCol()
    age = FloatCol()

Now you need a hierarchy of roles:

class Role(InheritableSQLObject):
    department = StringCol()

The magic starts here! You inherit the class from the special root class InheritableSQLObject and provide a set of attributes common for all roles. Other roles must be inherited from Role:

class Student(Role):
    year = IntCol()

class Professor(Role):
    timetable = StringCol()

Now you want a column in Person that can be interpreted as the role. Easy:

class Person(SQLObject):
    name = StringCol()
    age = FloatCol()
    role = ForeignKey("Role")

That's all, really! When asked for its role, Person returns the value of its .role attribute dereferenced and interpreted. Instead of returning an instance of class Role it returns an instance of the corresponding subclass - a Student or a Professor.

This is a brief explanation based on a task people meet most often, but of course it can be used far beyond the person/role task. I also omitted all details in the explanation. Now look at the real working program:

from sqlobject import *
from sqlobject.inheritance import InheritableSQLObject

__connection__ = "sqlite:/:memory:"

class Role(InheritableSQLObject):
   department = StringCol()

class Student(Role):
   year = IntCol()

class Professor(Role):
   timetable = StringCol(default=None)

class Person(SQLObject):
   name = StringCol()
   age = FloatCol()
   role = ForeignKey("Role", default=None)

Role.createTable()
Student.createTable()
Professor.createTable()
Person.createTable()

first_year = Student(department="CS", year=1)
lecturer = Professor(department="Mathematics")

student = Person(name="A student", age=21, role=first_year)
professor = Person(name="A professor", age=42, role=lecturer)

print student.role
print professor.role

It prints:

<Student 1 year=1 department='CS'>
<Professor 2 timetable=None department='Mathematics'>

You can get the list of all available roles:

print list(Role.select())

It prints:

[<Student 1 year=1 department='CS'>, <Professor 2 timetable=None department='Mathematics'>]

Look - you have gotten a list of Role's subclasses!

If you add a MultipleJoin column to Role, you can list all persons for a given role:

class Role(InheritableSQLObject):
    department = StringCol()
    persons = MultipleJoin("Person")

for role in Role.select():
    print role.persons

It prints:

[<Person 1 name='A student' age=21.0 roleID=1>]
[<Person 2 name='A professor' age=42.0 roleID=2>]

If you you want your persons to have many roles, use RelatedJoin:

class Role(InheritableSQLObject):
    department = StringCol()
    persons = RelatedJoin("Person")

class Student(Role):
    year = IntCol()

class Professor(Role):
    timetable = StringCol(default=None)

class Person(SQLObject):
    name = StringCol()
    age = FloatCol()
    roles = RelatedJoin("Role")

Role.createTable()
Student.createTable()
Professor.createTable()
Person.createTable()

first_year = Student(department="CS", year=1)
lecturer = Professor(department="Mathematics")

student = Person(name="A student", age=21)
student.addRole(first_year)
professor = Person(name="A professor", age=42)
professor.addRole(lecturer)

print student.roles
print professor.roles

for role in Role.select():
    print role.persons

It prints:

[<Student 1 year=1 department='CS'>]
[<Professor 2 timetable=None department='Mathematics'>]
[<Person 1 name='A student' age=21.0>]
[<Person 2 name='A professor' age=42.0>]

Who, What and How

Daniel Savard has implemented inheritance for SQLObject. In terms of ORM this is a kind of vertical inheritance. The only difference is that objects reference their leaves, not parents. Links to parents are reconstructed at run-time using the hierarchy of Python classes.

  • As suggested by Ian Bicking, each child class now has the same ID as the parent class. No more need for childID column and parent foreignKey (and a small speed boost).
  • No more need to call getSubClass, as the 'latest' child will always be returned when an instance of a class is created.
  • This version now seems to work correctly with addColumn, delColumn, addJoin and delJoin.

The following code:

from sqlobject.inheritance import InheritableSQLObject
class Person(InheritableSQLObject):
    firstName = StringCol()
    lastName = StringCol()

class Employee(Person):
    _inheritable = False
    position = StringCol()

will generate the following tables:

CREATE TABLE person (
    id INT PRIMARY KEY,
    child_name TEXT,
    first_name TEXT,
    last_name TEXT
);

CREATE TABLE employee (
    id INT PRIMARY KEY,
    position TEXT
)

A new class attribute _inheritable is added. When this new attribute is set to 1, the class is marked 'inheritable' and a new columns will automatically be added: childName (TEXT).

Each class that inherits from a parent class will get the same ID as the parent class. So, there is no need to keep track of parent ID and child ID, as they are the same.

The column childName will contain the name of the child class (for example 'Employee'). This will permit a class to always return its child class if available (a person that is also an employee will always return an instance of the employee class).

For example, the following code:

p = Person(firstName='John', lastName='Doe')
e = Employee(firstName='Jane', lastName='Doe', position='Chief')
p2 = Person.get(1)

Will create the following data in the database:

*Person*
id
    child_name
    first_name
    last_name
0
    Null
    John
    Doe
1
    Employee
    Jane
    Doe


*Employee*
id
    position
1
    Chief

You will still be able to ask for the attribute normally: e.firstName will return Jane and setting it will write the new value in the person table.

If you use p2, as p2 is a person object, you will get an employee object. person(0) will return a Person instance and will have the following attributes: firstName and lastName. person(1) or employee(1) will both return the same Employee instance and will have the following attributes: firstName, lastName and position.

Also, deleting a person or an employee that is linked will destroy both entries as one would expect.

The SQLObject q magic also works. Using these selects is valid:

Employee.select(AND(Employee.q.firstName == 'Jane', Employee.q.position == 'Chief')) will return Jane Doe
Employee.select(AND(Person.q.firstName == 'Jane', Employee.q.position == 'Chief')) will return Jane Doe
Employee.select(Employee.q.lastName == 'Doe') will only return Jane Doe (as Joe isn't an employee)
Person.select(Person.q.lastName == 'Doe') will return both entries.

The SQL 'where' clause will contain additional clauses when used with 'inherited' classes. These clauses are the link between the id and the parent id. This will look like the following request:

SELECT employee.id, person.first_name, person.last_name
FROM person, employee WHERE person.first_name = 'Jane'
AND employee.position = 'Chief' AND person.id = employee.id

Limitations and notes

  • Only single inheritance will work. It is not possible to inherit from multiple SQLObject classes.
  • It is possible to inherit from an inherited class and this will work well. In the above example, you can have a Chief class that inherits from Employee and all parents attributes will be available through the Chief class.
  • You may not redefine columns in an inherited class (this will raise an exception).
  • If you don't want 'childName' columns in your last class (one that will never be inherited), you must set '_inheritable' to False in this class.
  • The inheritance implementation is incompatible with lazy updates. Do not set lazyUpdate to True. If you need this, you have to patch SQLObject and override many methods - _SO_setValue(), sync(), syncUpdate() at least. Patches will be gladly accepted.
  • You'd better restrain yourself to simple use cases. The inheritance implementation is easily choked on more complex cases.
  • A join between tables inherited from the same parent produces incorrect result due to joins to the same parent table (they must use different aliases).
  • Inheritance works in two stages - first it draws the IDs from the parent table and then it draws the rows from the children tables. The first stage could fail if you try to do complex things. For example, Children.select(orderBy=Children.q.column, distinct=True) could fail because at the first stage inheritance generates a SELECT query for the parent table with ORDER BY the column from the children table.
  • I made it because I needed to be able to have automatic inheritance with linked tables.
  • This version works for me; it may not work for you. I tried to do my best but it is possible that I broke some things... So, there is no warranty that this version will work.
  • Thanks to Ian Bicking for SQLObject; this is a wonderful python module.
  • Although all the attributes are inherited, the same does not apply to sqlmeta data. Don't try to get a parent column via the sqlmeta.columns dictionary of an inherited InheritableSQLObject: it will raise a KeyError. The same applies to joins: the sqlmeta.joins list will be empty in an inherited InheritableSQLObject if a join has been defined in the parent class, even though the join method will work correctly.
  • If you have suggestion, bugs, or patch to this patch, you can contact the SQLObject team: <sqlobject-discuss at lists.sourceforge.net>
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.sybase.sybaseconnection-index.html0000644000175000017500000002057412754657340026670 0ustar phdphd00000000000000 Index of sqlobject.sybase.sybaseconnection module

Index of the sybaseconnection module

SQLObject-3.1.0/docs/html/module-sqlobject.sqlite-index.html0000644000175000017500000002607412754657336023344 0ustar phdphd00000000000000 Index of sqlobject.sqlite module

Index of the sqlite module

SQLObject-3.1.0/docs/html/rst.css0000711000175000017500000001330612754657230016100 0ustar phdphd00000000000000/* :Author: David Goodger, Ian Bicking :Contact: ianb@colorstudy.com :date: $Date: 2003/11/01 20:35:45 $ :version: $Revision: 1.3 $ :copyright: This stylesheet has been placed in the public domain. A modification of the default cascading style sheet (v.1.3) for the HTML output of Docutils. */ div#contents p.topic-title a { display: none; } em, i { /* Typically serif fonts have much nicer italics */ font-family: Times New Roman, Times, serif; } ul li { list-style-type: circle; } a.toc-backref { text-decoration: none; color: black; } a.toc-backref:hover { background-color: inherit; } h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6:hover { background-color: inherit; } cite { font-style: normal; font-family: monospace; font-weight: bold; } dd { margin-bottom: 0.5em; } div.abstract { margin: 2em 5em; } div.abstract p.topic-title { font-weight: bold; text-align: center; } div.attention, div.caution, div.danger, div.error, div.hint, div.important, div.note, div.tip, div.warning { background-color: #ccc; width: 40%; border: medium outset; padding: 3px; float: right line-height: normal; } div.attention p.admonition-title, div.caution p.admonition-title, div.danger p.admonition-title, div.error p.admonition-title, div.warning p.admonition-title { color: #c00; font-weight: bold; font-family: sans-serif; text-align: center; background-color: #999; display: block; margin: 0; } div.hint p.admonition-title, div.important p.admonition-title, div.note p.admonition-title, div.tip p.admonition-title { font-weight: bold; font-family: sans-serif; text-align: center; background-color: #999; display: block; margin: 0; } div.dedication { margin: 2em 5em; text-align: center; font-style: italic; } div.dedication p.topic-title { font-weight: bold; font-style: normal; } div.figure { margin-left: 2em; } div.footer, div.header { font-size: smaller; } div.system-messages { margin: 5em; } div.system-messages h1 { color: red; } div.system-message { border: medium outset; padding: 1em; } div.system-message p.system-message-title { color: red; font-weight: bold; } div.topic { margin: 2em; } h3 a.toc-backref, h4 a.toc-backref, h5 a.toc-backref, h6 a.toc-backref { color: #000; } h1.title { text-align: center; } h2.subtitle { text-align: center; } hr { width: 75%; } ol.simple, ul.simple { margin-bottom: 1em; } ul.contents li { list-style: none; margin: 0; padding: 0; } ul.contents { position: fixed; top: 0px; right: 0px; background-color: #fd9; border-left: 1px solid #f70; border-bottom: 1px solid #f70; width: 200px; padding: 0; margin: 0; } ul.contents a { padding: 2px 1em 2px 1em; display: block; text-decoration: none; color: #400; } ul.contents a:hover { background-color: #f80; color: #fff; } ul.contents li.header { padding: 5px 1px 3px 0; font-weight: bold; } ol.arabic { list-style: decimal; } ol.loweralpha { list-style: lower-alpha; } ol.upperalpha { list-style: upper-alpha; } ol.lowerroman { list-style: lower-roman; } ol.upperroman { list-style: upper-roman; } p.caption { font-style: italic; } p.credits { font-style: italic; font-size: smaller; } p.first { margin-top: 0; } p.label { white-space: nowrap; } p.topic-title { font-weight: bold; } pre.address { margin-bottom: 0; margin-top: 0; font-family: serif; font-size: 100%; } pre.line-block { font-family: serif; font-size: 100%; } pre.literal-block, pre.doctest-block { margin-left: 2em; margin-right: 2em; background-color: #eee; border: thin black solid; padding: 5px; } span.classifier { font-family: sans-serif; font-style: oblique; } span.classifier-delimiter { font-family: sans-serif; font-weight: bold; } span.interpreted { font-family: sans-serif; } span.option-argument { font-style: italic; } span.pre { white-space: pre; } span.problematic { color: red; } table { margin-top: 0.5em; margin-bottom: 0.5em; } table.citation { border-left: solid thin gray; padding-left: 0.5ex } table.docinfo { } table.footnote { border-left: solid thin black; padding-left: 0.5ex; } td, th { padding-left: 0.5em; padding-right: 0.5em; vertical-align: top; } td > p:first-child, th > p:first-child { margin-top: 0em; } th.docinfo-name, th.field-name { font-weight: bold; text-align: left; white-space: nowrap; } h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt { font-size: 100%; } code, tt { color: #006; } ul.auto-toc { list-style-type: none; } /***************************************** * Doctest embedded examples *****************************************/ span.doctest-url { background-color: #eee; border-top: 2px outset #666; border-left: 2px outset #666; border-right: 2px outset #666; padding: 0.25em; } div.doctest-example { border: outset 5px #666; background-color: #eee; font-family: default; padding: 0.5em; } div.doctest-example h1 { background-color: inherit; border: none; color: inherit; font-family: default; } div.doctest-example tt { color: inherit; } div.doctest-status { background-color: #060; color: #fff; } span.doctest-header { background-color: #ccc; font-family: monospace; } pre.doctest-errors { border: none; background-color: #333; color: #600; } div.source-code { background-color: #000; border: inset #999 3px; overflow: auto; } pre.source-code { background-color: #000; border: inset #999 3px; overflow: auto; font-family: monospace; color: #fff; } span.source-filename { background-color: #000; border-top: 2px outset #999; border-left: 2px outset #999; border-right: 2px outset #999; padding: 0.25em; color: #fff } SQLObject-3.1.0/docs/html/class-sqlobject.col.DateTimeCol.html0000644000175000017500000001033212754657352023450 0ustar phdphd00000000000000

DateTimeCol

The DateTimeCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

f now() ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.DataError.html0000644000175000017500000001324212754657322024246 0ustar phdphd00000000000000

DataError

The DataError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOBigIntCol.html0000644000175000017500000002425512754657352023403 0ustar phdphd00000000000000

SOBigIntCol

The SOBigIntCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

f addSQLAttrs(self, str) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOTinyIntCol.html0000644000175000017500000002430512754657351023620 0ustar phdphd00000000000000

SOTinyIntCol

The SOTinyIntCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

f addSQLAttrs(self, str) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.joins.RelatedJoin.html0000644000175000017500000001034012754657353024063 0ustar phdphd00000000000000

RelatedJoin

The RelatedJoin class is accessible via the sqlobject.joins module.

Attributes

a joinMethodName

<property object at 0xb65c6c0c>

a name

<property object at 0xb65c6c0c>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, otherClass=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sybase.sybaseconnection.SybaseConnection.html0000644000175000017500000002453712754657341030654 0ustar phdphd00000000000000

SybaseConnection

The SybaseConnection class is accessible via the sqlobject.sybase.sybaseconnection module.

Attributes

a supportTransactions

False

a NumericType

None

a SHOW_COLUMNS

"SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '%s'"

a SHOW_TABLES

"SELECT name FROM sysobjects WHERE type='U'"

a HAS_IDENTITY

"\n       SELECT col.name, col.status, obj.name\n       FROM syscolumns col\n       JOIN sysobjects obj\n       ON obj.id = col.id\n       WHERE obj.name = '%s'\n             AND (col.status & 0x80) = 0x80\n    "

a schemes

['sybase']

a dbName

'sybase'

Methods

f __init__(self, db, user, password='', host='localhost', port=None, locking=1, **kw) ...

f insert_id(self, conn) ...

Sybase adapter/cursor does not support the insert_id method.

f makeConnection(self) ...

f createReferenceConstraint(self, soClass, col) ...

f createColumn(self, soClass, col) ...

f createIDColumn(self, soClass) ...

f createIndexSQL(self, soClass, index) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f addColumn(self, tableName, column) ...

f delColumn(self, sqlmeta, column) ...

f columnsFromSchema(self, tableName, soClass) ...

f guessClass(self, t) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.Transaction.html0000644000175000017500000001715012754657340025475 0ustar phdphd00000000000000

Transaction

The Transaction class is accessible via the sqlobject.dbconnection module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, dbConnection) ...

f assertActive(self) ...

f query(self, s) ...

f queryAll(self, s) ...

f queryOne(self, s) ...

f queryInsertID(self, soInstance, id, names, values) ...

f iterSelect(self, select) ...

f commit(self, close=False) ...

f rollback(self) ...

f begin(self) ...

f __del__(self) ...

f close(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.views.ViewSQLObjectField.html0000644000175000017500000003404512754657321025266 0ustar phdphd00000000000000

ViewSQLObjectField

The ViewSQLObjectField class is accessible via the sqlobject.views module.

Methods

f __init__(self, alias, *arg) ...

f __sqlrepr__(self, db) ...

f tablesUsedImmediate(self) ...

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.UuidCol.html0000644000175000017500000000750212754657352022667 0ustar phdphd00000000000000

UuidCol

The UuidCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOEnumCol.html0000644000175000017500000002337112754657351023130 0ustar phdphd00000000000000

SOEnumCol

The SOEnumCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.constraints.BadValue.html0000644000175000017500000001321012754657323024567 0ustar phdphd00000000000000

BadValue

The BadValue class is accessible via the sqlobject.constraints module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, desc, obj, col, value, *args) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.main.NoDefault.html0000644000175000017500000000171112754657334023347 0ustar phdphd00000000000000

NoDefault

The NoDefault class is accessible via the sqlobject.main module.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.util-index.html0000644000175000017500000001650312754657321023006 0ustar phdphd00000000000000 Index of sqlobject.util module

Index of the util module

SQLObject-3.1.0/docs/html/class-sqlobject.col.UnicodeCol.html0000644000175000017500000000752312754657350023350 0ustar phdphd00000000000000

UnicodeCol

The UnicodeCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.TinyIntCol.html0000644000175000017500000000752312754657350023360 0ustar phdphd00000000000000

TinyIntCol

The TinyIntCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.mysql.mysqlconnection.ErrorMessage.html0000644000175000017500000002527412754657316027543 0ustar phdphd00000000000000

ErrorMessage

The ErrorMessage class is accessible via the sqlobject.mysql.mysqlconnection module.

Methods

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __rmod__(...) ...

x.__rmod__(y) <==> y%x

f __rmul__(...) ...

x.__rmul__(n) <==> n*x

f __sizeof__(...) ...

S.__sizeof__() -> size of S in memory, in bytes

f __getnewargs__(...) ...

f __lt__(...) ...

x.__lt__(y) <==> x<y

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

f __contains__(...) ...

x.__contains__(y) <==> y in x

f __format__(...) ...

S.__format__(format_spec) -> string

Return a formatted version of S as described by format_spec.

f __len__(...) ...

x.__len__() <==> len(x)

f __ne__(...) ...

x.__ne__(y) <==> x!=y

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __add__(...) ...

x.__add__(y) <==> x+y

f __gt__(...) ...

x.__gt__(y) <==> x>y

f __eq__(...) ...

x.__eq__(y) <==> x==y

f __mod__(...) ...

x.__mod__(y) <==> x%y

f __le__(...) ...

x.__le__(y) <==> x<=y

f __mul__(...) ...

x.__mul__(n) <==> x*n

f __ge__(...) ...

x.__ge__(y) <==> x>=y

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sybase.html0000644000175000017500000000464012754657340022212 0ustar phdphd00000000000000

sybase

The sybase module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.sybase'

Functions

f builder() ...

Modules

The sqlobject.sybase module exposes 1 submodules:

sybaseconnection

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.index.DatabaseIndex.html0000644000175000017500000001235412754657323024350 0ustar phdphd00000000000000

DatabaseIndex

This takes a variable number of parameters, each of which is a column for indexing. Each column may be a column object or the string name of the column (not the database name). You may also use dictionaries, to further customize the indexing of the column. The dictionary may have certain keys:

The DatabaseIndex class is accessible via the sqlobject.index module.

'column':
The column object or string identifier.
'length':
MySQL will only index the first N characters if this is given. For other databases this is ignored.
'expression':
You can create an index based on an expression, e.g., 'lower(column)'. This can either be a string or a sqlbuilder expression.

Further keys may be added to the column specs in the future.

The class also take the keyword argument unique ; if true then a UNIQUE index is created.

Attributes

a name

<property object at 0xb6606234>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, *columns, **kw) ...

f setName(self, value) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.compat-index.html0000644000175000017500000000577712754657342023332 0ustar phdphd00000000000000 Index of sqlobject.compat module

Index of the compat module

SQLObject-3.1.0/docs/html/class-sqlobject.views.ViewSQLObject.html0000644000175000017500000002116012754657321024314 0ustar phdphd00000000000000

ViewSQLObject

A SQLObject class that derives all it's values from other SQLObject classes. Columns on subclasses should use SQLBuilder constructs for dbName, and sqlmeta should specify:

The ViewSQLObject class is accessible via the sqlobject.views module.

  • idName as a SQLBuilder construction
  • clause as SQLBuilder clause for specifying join conditions or other restrictions
  • table as an optional alternate name for the class alias

See test_views.py for simple examples.

Attributes

a childName

None

a j

view_sql_object

a q

view_sql_object

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __classinit__(cls, new_attrs) ...

f __init__(self, **kw) ...

f __sqlrepr__(self, db) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __getstate__(self) ...

f __setstate__(self, d) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.firebird-index.html0000644000175000017500000002364612754657333023630 0ustar phdphd00000000000000 Index of sqlobject.firebird module

Index of the firebird module

SQLObject-3.1.0/docs/html/class-sqlobject.events.CreateTableSignal.html0000644000175000017500000000764712754657341025373 0ustar phdphd00000000000000

CreateTableSignal

Called when a table is created. If ifNotExists==True and the table exists, this event is not called.

The CreateTableSignal class is accessible via the sqlobject.events module.

Called with (cls, connection, extra_sql, post_funcs). extra_sql is a list (which can be appended to) of extra SQL statements to be run after the table is created. post_funcs functions are called with (cls, connection) after the table has been created. Those functions are not called simply when constructing the SQL.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.joins.SQLRelatedJoin.html0000644000175000017500000001037312754657353024451 0ustar phdphd00000000000000

SQLRelatedJoin

The SQLRelatedJoin class is accessible via the sqlobject.joins module.

Attributes

a joinMethodName

<property object at 0xb65c6c0c>

a name

<property object at 0xb65c6c0c>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, otherClass=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mysql.html0000644000175000017500000000462212754657315022073 0ustar phdphd00000000000000

mysql

The mysql module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.mysql'

Functions

f builder() ...

Modules

The sqlobject.mysql module exposes 1 submodules:

mysqlconnection

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.StringCol.html0000644000175000017500000000751312754657346023234 0ustar phdphd00000000000000

StringCol

The StringCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.postgres.html0000644000175000017500000000466012754657317022600 0ustar phdphd00000000000000

postgres

The postgres module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.postgres'

Functions

f builder() ...

Modules

The sqlobject.postgres module exposes 1 submodules:

pgconnection

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.mssql.html0000644000175000017500000000462212754657323022064 0ustar phdphd00000000000000

mssql

The mssql module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.mssql'

Functions

f builder() ...

Modules

The sqlobject.mssql module exposes 1 submodules:

mssqlconnection

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.AddColumnSignal.html0000644000175000017500000000722212754657341025053 0ustar phdphd00000000000000

AddColumnSignal

Called when a column is added to a class, with arguments (cls, connection, column_name, column_definition, changeSchema, post_funcs). This is called after the column has been added, and is called for each column after class creation.

The AddColumnSignal class is accessible via the sqlobject.events module.

post_funcs are called with (cls, so_column_obj)

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOTimedeltaCol.html0000644000175000017500000002470112754657347024137 0ustar phdphd00000000000000

SOTimedeltaCol

The SOTimedeltaCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, name, soClass, creationOrder, dbName=None, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, notNone=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, unique=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None) ...

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOStringLikeCol.html0000644000175000017500000002407412754657346024304 0ustar phdphd00000000000000

SOStringLikeCol

A common ancestor for SOStringCol and SOUnicodeCol

The SOStringLikeCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createValidators(self) ...

Create a list of validators for the column.

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.Signal.html0000644000175000017500000000653212754657342023270 0ustar phdphd00000000000000

Signal

Base event for all SQLObject events.

The Signal class is accessible via the sqlobject.events module.

In general the sender for these methods is the class, not the instance.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.__version__.html0000644000175000017500000000734412754657341023212 0ustar phdphd00000000000000

__version__

The __version__ module is accessible via the sqlobject module.

Attributes

a major

3

a release_level

'final'

a version_info

(3, 1, 0, 'final', 0)

a __package__

None

a micro

0

a version

'3.1.0'

a serial

0

a minor

1

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Select.html0000644000175000017500000005144512754657330024134 0ustar phdphd00000000000000

Select

The Select class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, items=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, where=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, groupBy=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, having=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, orderBy=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, limit=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, join=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, lazyColumns=False, distinct=False, start=0, end=None, reversed=False, forUpdate=False, clause=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, staticTables=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, distinctOn=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>) ...

f clone(self, **newOps) ...

f newItems(self, items) ...

f newClause(self, new_clause) ...

f orderBy(self, orderBy) ...

f unlimited(self) ...

f limit(self, limit) ...

f lazyColumns(self, value) ...

f reversed(self) ...

f distinct(self) ...

f filter(self, filter_clause) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandCreate.html0000644000175000017500000003565412754657313026305 0ustar phdphd00000000000000

CommandCreate

The CommandCreate class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

''

a parser

<optparse.OptionParser instance at 0xb64cf5ec>

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'create'

a summary

'Create tables'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandHelp.html0000644000175000017500000003554212754657313025766 0ustar phdphd00000000000000

CommandHelp

The CommandHelp class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

''

a parser

<optparse.OptionParser instance at 0xb64e744c>

a aliases

()

a max_args

1

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'help'

a summary

'Show help'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLObjectTable.html0000644000175000017500000004151712754657330025452 0ustar phdphd00000000000000

SQLObjectTable

The SQLObjectTable class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

f __init__(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.Boolean.html0000644000175000017500000000664512754657340024576 0ustar phdphd00000000000000

Boolean

A bool class that also understands some special string keywords

The Boolean class is accessible via the sqlobject.dbconnection module.

Understands: yes/no, true/false, on/off, 1/0, case ignored.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.classregistry.html0000644000175000017500000001221712754657334023624 0ustar phdphd00000000000000

classregistry

classresolver.py
2 February 2004, Ian Bicking <ianb@colorstudy.com>

The classregistry module is accessible via the sqlobject module.

Resolves strings to classes, and runs callbacks when referenced classes are created.

Classes are referred to only by name, not by module. So that identically-named classes can coexist, classes are put into individual registries, which are keyed on strings (names). These registries are created on demand.

Use like:

>>> import classregistry
>>> registry = classregistry.registry('MyModules')
>>> def afterMyClassExists(cls):
...    print('Class finally exists: %s' % cls)
>>> registry.addClassCallback('MyClass', afterMyClassExists)
>>> class MyClass:
...    pass
>>> registry.addClass(MyClass)
Class finally exists: MyClass

Attributes

a __package__

None

a MasterRegistry

<sqlobject.classregistry._MasterRegistry object at 0xb602834c>

Functions

f registry(self, item) ...

f findClass(name, class_registry=None) ...

Classes

C ClassRegistry(...) ...

We'll be dealing with classes that reference each other, so class C1 may reference C2 (in a join), while C2 references C1 right back. Since classes are created in an order, there will be a point when C1 exists but C2 doesn't. So we deal with classes by name, and after each class is created we try to fix up any references by replacing the names with actual classes.

Here we keep a dictionaries of class names to classes -- note that the classes might be spread among different modules, so since we pile them together names need to be globally unique, to just module unique. Like needSet below, the container dictionary is keyed by the class registry.

This class contains 9 members.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.include.tests.test_hashcol-index.html0000644000175000017500000001441212754657317027276 0ustar phdphd00000000000000 Index of sqlobject.include.tests.test_hashcol module

Index of the test_hashcol module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLJoin.html0000644000175000017500000004026312754657327024176 0ustar phdphd00000000000000

SQLJoin

The SQLJoin class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table1, table2, op=',') ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.DateCol.html0000644000175000017500000000750212754657350022634 0ustar phdphd00000000000000

DateCol

The DateCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.AliasTable.html0000644000175000017500000004207112754657333024714 0ustar phdphd00000000000000

AliasTable

The AliasTable class is accessible via the sqlobject.sqlbuilder module.

Attributes

a as_string

''

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f execute(self, executor) ...

f __init__(self, table, alias=None) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.maxdb-index.html0000644000175000017500000003177512754657342023137 0ustar phdphd00000000000000 Index of sqlobject.maxdb module

Index of the maxdb module

SQLObject-3.1.0/docs/html/module-sqlobject.index-index.html0000644000175000017500000001613612754657323023144 0ustar phdphd00000000000000 Index of sqlobject.index module

Index of the index module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Insert.html0000644000175000017500000004031412754657332024154 0ustar phdphd00000000000000

Insert

The Insert class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table, valueList=None, values=None, template=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sresults.html0000644000175000017500000000430312754657344022610 0ustar phdphd00000000000000

sresults

The sresults module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject'

Classes

C SelectResults(...) ...

This class contains 27 members.

See the source for more information.

SQLObject-3.1.0/docs/html/Versioning.html0000644000175000017500000001352712754657232017603 0ustar phdphd00000000000000

Author: David Turner, The Open Planning Project

Versioning

Why

You have a table where rows can be altered, such as a table of wiki pages. You want to retain a history of changes for auditing, backup, or tracking purposes.

You could write a decorator that stores old versions and manage all access to this object through it. Or you could take advantage of the event system in SQLObject 0.8+ and just catch row accesses to the object. SQLObject's versioning module does this for you. And it even works with inheritance!

How

Here's how to set it up:

class MyClass(SQLObject):
    name = StringCol()
    versions = Versioning()

To use it, just create an instance as usual:

mc = MyClass(name='fleem')

Then make some changes and check out the results:

mc.set(name='morx')
assert mc.versions[0].name == 'fleem'

You can also restore to a previous version:

mc.versions[0].restore()
assert mc.name == "fleem"

Inheritance

There are three ways versioning can be used with inheritance:

  1. Parent versioned, children unversioned:

    class Base(InheritableSQLObject):
    name = StringCol()
    versions = Versioning()

class Child(Base):
    toy = StringCol()

In this case, when changes are made to an instance of Base, new versions are created. But when changes are made to an instance of Child, no new versions are created.

  1. Children versioned, parents unversioned.

In this case, when changes are made to an instance of Child, new versions are created. But when changes are made to an instance of Base, no new versions are created. The version data for Child contains all of the columns from child and from base, so that a full restore is possible.

  1. Both children and parents versioned.

In this case, changes to either Child or Base instances create new versions, but in different tables. Child versions still contain all Base data, and a change to a Child only creates a new Child version, not a new Base version.

Version Tables

Versions are stored in a special table which is created when the table for a versioned class is created. Version tables are not altered when the main table is altered, so if you add a column to your main class, you will need to manually add the column to your version table.

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.util.csvexport-index.html0000644000175000017500000000644612754657321025047 0ustar phdphd00000000000000 Index of sqlobject.util.csvexport module

Index of the csvexport module

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.NotSupportedError.html0000644000175000017500000001340212754657323026042 0ustar phdphd00000000000000

NotSupportedError

The NotSupportedError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.InterfaceError.html0000644000175000017500000001333612754657322025301 0ustar phdphd00000000000000

InterfaceError

The InterfaceError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Field.html0000644000175000017500000004075312754657332023742 0ustar phdphd00000000000000

Field

The Field class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f __init__(self, tableName, fieldName) ...

f __sqlrepr__(self, db) ...

f tablesUsedImmediate(self) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLExpression.html0000644000175000017500000003710112754657331025426 0ustar phdphd00000000000000

SQLExpression

The SQLExpression class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.mssql.mssqlconnection.MSSQLConnection.html0000644000175000017500000003064212754657324030042 0ustar phdphd00000000000000

MSSQLConnection

The MSSQLConnection class is accessible via the sqlobject.mssql.mssqlconnection module.

Attributes

a supportTransactions

True

a limit_re

<_sre.SRE_Pattern object at 0xb6540930>

a SHOW_COLUMNS

"\n        select\n                name,\n                length,\n                (       select name\n                        from systypes\n                        where cast(xusertype as int)= cast(sc.xtype as int)\n                ) datatype,\n                prec,\n                scale,\n                isnullable,\n                cdefault,\n                m.text default_text,\n                isnull(len(autoval),0) is_identity\n        from syscolumns sc\n        LEFT OUTER JOIN syscomments m on sc.cdefault = m.id\n                AND m.colid = 1\n        where\n                sc.id in (select id\n                        from sysobjects\n                where name = '%s')\n        order by\n                colorder"

a SHOW_TABLES

"SELECT name FROM sysobjects WHERE type='U'"

a HAS_IDENTITY

"\n       select 1\n       from INFORMATION_SCHEMA.COLUMNS\n       where TABLE_NAME = '%s'\n       and COLUMNPROPERTY(object_id(TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1\n    "

a schemes

['mssql']

a dbName

'mssql'

Methods

f __init__(self, db, user, password='', host='localhost', port=None, autoCommit=0, **kw) ...

f insert_id(self, conn) ...

insert_id method.

f makeConnection(self) ...

f createReferenceConstraint(self, soClass, col) ...

f createColumn(self, soClass, col) ...

f createIDColumn(self, soClass) ...

f createIndexSQL(self, soClass, index) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f addColumn(self, tableName, column) ...

f delColumn(self, sqlmeta, column) ...

f columnsFromSchema(self, tableName, soClass) ...

f guessClass(self, t, size, precision, scale) ...

Here we take raw values coming out of syscolumns and map to SQLObject class types.

f server_version(self) ...

Get server version: 8 - 2000 9 - 2005 10 - 2008 11 - 2012

f can_use_max_types(self) ...

f can_use_microseconds(self) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.declarative.DeclarativeMeta.html0000644000175000017500000002523612754657344026070 0ustar phdphd00000000000000

DeclarativeMeta

The DeclarativeMeta class is accessible via the sqlobject.declarative module.

Attributes

a __weakrefoffset__

184

a __mro__

(<class 'sqlobject.declarative.DeclarativeMeta'>,
 <type 'type'>,
 <type 'object'>)

a __bases__

(<type 'type'>,)

a __dictoffset__

132

a __itemsize__

20

a __name__

'DeclarativeMeta'

a __basicsize__

436

a __flags__

-2146543621

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __lt__(...) ...

x.__lt__(y) <==> x<y

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

f __subclasses__(...) ...

__subclasses__() -> list of immediate subclasses

f __format__(...) ...

default object formatter

f __call__(...) ...

x.__call__(...) <==> x(...)

f __instancecheck__(...) ...

__instancecheck__() -> bool check if an object is an instance

f __ne__(...) ...

x.__ne__(y) <==> x!=y

f __subclasscheck__(...) ...

__subclasscheck__() -> bool check if a class is a subclass

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __gt__(...) ...

x.__gt__(y) <==> x>y

f __eq__(...) ...

x.__eq__(y) <==> x==y

f __le__(...) ...

x.__le__(y) <==> x<=y

f __ge__(...) ...

x.__ge__(y) <==> x>=y

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.maxdb.maxdbconnection.maxdbException.html0000644000175000017500000001353112754657343027764 0ustar phdphd00000000000000

maxdbException

The maxdbException class is accessible via the sqlobject.maxdb.maxdbconnection module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.main.SQLObject.html0000644000175000017500000004377412754657335023274 0ustar phdphd00000000000000

SQLObject

The SQLObject class is accessible via the sqlobject.main module.

Attributes

a childName

None

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __classinit__(cls, new_attrs) ...

f get(cls, id, connection=None, selectResults=None) ...

f sync(self) ...

f syncUpdate(self) ...

f expire(self) ...

f set(self, _suppress_set_sig=False, **kw) ...

f __init__(self, **kw) ...

f select(cls, clause=None, clauseTables=None, orderBy=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, limit=None, lazyColumns=False, reversed=False, distinct=False, connection=None, join=None, forUpdate=False) ...

f selectBy(cls, connection=None, **kw) ...

f tableExists(cls, connection=None) ...

f dropTable(cls, ifExists=False, dropJoinTables=True, cascade=False, connection=None) ...

f createTable(cls, ifNotExists=False, createJoinTables=True, createIndexes=True, applyConstraints=True, connection=None) ...

f createTableSQL(cls, createJoinTables=True, createIndexes=True, connection=None) ...

f createJoinTables(cls, ifNotExists=False, connection=None) ...

f createJoinTablesSQL(cls, connection=None) ...

f createIndexes(cls, ifNotExists=False, connection=None) ...

f createIndexesSQL(cls, connection=None) ...

f dropJoinTables(cls, ifExists=False, connection=None) ...

f clearTable(cls, connection=None, clearJoinTables=True) ...

f destroySelf(self) ...

f delete(cls, id, connection=None) ...

f deleteMany(cls, where=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, connection=None) ...

f deleteBy(cls, connection=None, **kw) ...

f __sqlrepr__(self, db) ...

f sqlrepr(cls, value, connection=None) ...

f coerceID(cls, value) ...

f setConnection(cls, value) ...

f tablesUsedImmediate(self) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __getstate__(self) ...

f __setstate__(self, d) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.include.tests.html0000644000175000017500000000401112754657317023504 0ustar phdphd00000000000000

tests

The tests module is accessible via the sqlobject.include module.

Attributes

a __package__

None

Modules

The sqlobject.include.tests module exposes 1 submodules:

test_hashcol

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLConstant.html0000644000175000017500000004132212754657327025065 0ustar phdphd00000000000000

SQLConstant

The SQLConstant class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, const) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.cache.CacheFactory.html0000644000175000017500000002471012754657316024144 0ustar phdphd00000000000000

CacheFactory

CacheFactory caches object creation. Each object should be referenced by a single hashable ID (note tuples of hashable values are also hashable).

The CacheFactory class is accessible via the sqlobject.cache module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, cullFrequency=100, cullFraction=2, cache=True) ...

Every cullFrequency times that an item is retrieved from this cache, the cull method is called.

The cull method then expires an arbitrary fraction of the cached objects. The idea is at no time will the cache be entirely emptied, placing a potentially high load at that moment, but everything object will have its time to go eventually. The fraction is given as an integer, and one in that many objects are expired (i.e., the default is 1/2 of objects are expired).

By setting cache to False, items won't be cached.

However, in all cases a weak reference is kept to created objects, and if the object hasn't been garbage collected it will be returned.

f tryGet(self, id) ...

This returns None, or the object in cache.

f get(self, id) ...

This method can cause deadlocks! tryGet is safer

This returns the object found in cache, or None. If None, then the cache will remain locked! This is so that the calling function can create the object in a threadsafe manner before releasing the lock. You should use this like (note that cache is actually a CacheSet object in this example):

obj = cache.get(some_id, my_class)
if obj is None:
    try:
        obj = create_object(some_id)
        cache.put(some_id, my_class, obj)
    finally:
        cache.finishPut(cls)

This method checks both the main cache (which retains references) and the 'expired' cache, which retains only weak references.

f put(self, id, obj) ...

Puts an object into the cache. Should only be called after .get(), so that duplicate objects don't end up in the cache.

f finishPut(self) ...

Releases the lock that is retained when .get() is called and returns None.

f created(self, id, obj) ...

Inserts and object into the cache. Should be used when no one else knows about the object yet, so there cannot be any object already in the cache. After a database INSERT is an example of this situation.

f cull(self) ...

Runs through the cache and expires objects

E.g., if cullFraction is 3, then every third object is moved to the 'expired' (aka weakref) cache.

f clear(self) ...

Removes everything from the cache. Warning! This can cause duplicate objects in memory.

f expire(self, id) ...

Expires a single object. Typically called after a delete. Doesn't even keep a weakref. (@@: bad name?)

f expireAll(self) ...

Expires all objects, moving them all into the expired/weakref cache.

f allIDs(self) ...

Returns the IDs of all objects in the cache.

f getAll(self) ...

Return all the objects in the cache.

See the source for more information.

SQLObject-3.1.0/docs/html/News5.html0000644000175000017500000007342612754657232016465 0ustar phdphd00000000000000 News

News

SQLObject 2.2.1

Released 10 May 2016.

  • Fix a bug in sqlbuilder.CONCAT (inherit from SQLExpression).

SQLObject 2.2.0

Released 8 May 2016.

Features & Interface

  • Add function col.use_microseconds(True/False). Default is to use microseconds (True).
  • For MSSQL use datetime2(6) and time(6) columns.
  • Columns for ForeignKey are created using idType of the referenced table.

Minor features

  • Add sqlbuilder.CONCAT to generate concatenation command (either using function CONCAT() or '||' operator).
  • Minor refactoring to pave the way to Python 3 was merged from SQLObject 1.6.7.
  • Document MSSQL server versions -- merged from SQLObject 1.7.6.

Bugfixes

  • Fix a bug: mxDateTime doesn't support microseconds; %s in mxDateTime format means ticks.

Tests

  • Speedup SQLite connections in tests -- merged from SQLObject 1.7.6.
  • Added new test helper setupCyclicClasses to setup classes with mutual references.

SQLObject 2.1.2

Released 15 Mar 2015.

SQLObject 2.1.1

Released 10 Mar 2015.

SQLObject 2.1.0

Released 6 Jan 2015.

Minor features

  • In queries generated with SQLObject's tables columns are sorted in the order they are declared in the table.
  • In queries generated with sqlbuilder's Insert/Update, if values are passed using dictionaries, columns are sorted alphabetically.
  • Tables in SELECT...FROM clause are sorted alphabetically.
  • MySQLConnection, PostgresConnection and SQLiteConnection have got a new method listDatabases() that lists databases in the connection and returns a list of names.
  • MySQLConnection, PostgresConnection and SQLiteConnection have got a new method listTables() that returns a list of table names in the database.

SQLObject 2.0.0

Released 20 Dec 2014.

Features & Interface

  • DateTimeCol and TimeCol can read and write values with microseconds.

    WARNING: microseconds are supported by MariaDB since version 5.3.0 and by MySQL since version 5.6.4, and even these versions require special handling: columns to store microseconds have to be declared with precision 6: TIME(6), DATETIME(6), TIMESTAMP(6). SQLObject does the right thing when creating a new database but existing databases have to be changed: run something like ALTER TABLE name MODIFY COLUMN col TIME(6) for every column that you want to store microseconds.

    For MSSQL use datetime2(6) and time(6) columns. They are available since MS SQL Server 2008.

    WARNING: backward compatibility problem! Date/Time columns created with microseconds cannot be read back from SQLite databases (and perhaps other backends) with versions of SQLObject older than 1.7.

Minor features

  • PostgresConnection, when used with fromDatabase=True, sets alternateID for unique columns.

Development

  • Development was switched from Subversion to git.

Documentation

  • Old news were restored back to version 0.2.1.
  • News.txt was split into 5 small files.

SQLObject 1.7.6

SQLObject 1.7.5

Released 15 Mar 2015.

SQLObject 1.7.4

Released 10 Mar 2015.

SQLObject 1.7.3

Released 18 Dec 2014.

  • Documentation updates and setup.py change were ported from SQLObject 1.5.6.

SQLObject 1.7.2

Released 14 Dec 2014.

  • Fix a bug: zero-pad microseconds on the right, not on the left; 0.0835 seconds means 83500 microseconds.

SQLObject 1.7.1

Released 11 Dec 2014.

  • Documentation updates and setuptools change were ported from SQLObject 1.5.5.

SQLObject 1.7.0

Released 8 Dec 2014.

Features & Interface

  • Python 2.5 is no longer supported. The minimal supported version is Python 2.6.
  • DateTimeCol and TimeCol can read values with microseconds (created by SQLObject 2.0) but do not write microseconds back.

Minor features

  • Upgrade ez_setup to 2.2.

Bugfixes

SQLObject 1.6.7

  • Minor refactoring to pave the way to Python 3: replace calls like unicode(data, encoding) with data.decode(encoding).
  • Document MSSQL server versions.
  • Minor fix in HashCol.
  • Speedup SQLite connections in tests.

SQLObject 1.6.6

Released 15 Mar 2015.

  • Use fdb adapter for Firebird.

SQLObject 1.6.5

Released 10 Mar 2015.

  • Minor fix in PostgresConnection: close the cursor and connection in _createOrDropDatabase even after an error.

SQLObject 1.6.4

Released 18 Dec 2014.

  • Documentation updates and setup.py change were ported from SQLObject 1.5.6.

SQLObject 1.6.3

Released 11 Dec 2014.

  • Documentation updates and setuptools change were ported from SQLObject 1.5.5.

SQLObject 1.6.2

Released 8 Dec 2014.

SQLObject 1.6.1

Released 26 Oct 2014.

SQLObject 1.6.0

Released 15 May 2014.

Features & Interface

  • Python 2.4 is no longer supported. The minimal supported version is Python 2.5.
  • Support for Python 2.5 is declared obsolete and will be removed in the next release.

Minor features

  • Upgrade ez_setup to 1.4.2.

Bugfixes

Development

  • Development switched from Subvesion to git.

SQLObject 1.5.6

Released 18 Dec 2014.

  • Extend setup.py: include docs and tests into the egg.

SQLObject 1.5.5

Released 11 Dec 2014.

  • Documentation update: change URLs for development with git, add Travis CI build status image.
  • Extend sdist: include everything into source distribution.

SQLObject 1.5.4

Released 8 Dec 2014.

  • Fix a minor bug in MSSQLConnection: do not override callable server_version with a non-callable.

SQLObject 1.5.3

Released 26 Oct 2014.

  • Allow unicode in .orderBy(u'-column').

Development

  • Development switched from Subvesion to git.

SQLObject 1.5.2

Released 13 Apr 2014.

  • Adapt duplicate error message strings for SQLite 3.8.

SQLObject 1.5.1

Released 15 Dec 2013.

  • SQLiteConnection.close() now closes and reopens a connection to in-memory database.

SQLObject 1.5.0

Released 5 Oct 2013.

Features & Interface

  • Helpers for class Outer were changed to lookup columns in table's declarations.
  • Support for Python 2.4 is declared obsolete and will be removed in the next release.

Minor features

  • When a PostgresConnection raises an exception the instance has code/error attributes copied from psycopg2's pgcode/pgerror attributes.
  • Encode unicode enum values to str.
  • Removed setDeprecationLevel from the list of public functions.
  • A number of fixes for tests.

Bugfixes

  • A bug was fixed in DBConnection.close(); close() doesn't raise an UnboundLocalError if connection pool is empty.
  • Fixed parameters for pymssql.

Documentation

  • GNU LGPL text was added as docs/LICENSE file.
  • Old FSF address was changed to the new one.

SQLObject 1.4.1

Released 26 May 2013.

SQLObject 1.4.0

Released 18 May 2013.

Features & Interface

  • Support for PostgreSQL 8.1 is dropped. The minimal supported version of PostgreSQL is 8.2 now.
  • Optimization in PostgresConnection: use INSERT...RETURNING id to get the autoincremented id in one query instead of two (INSERT + SELECT id).
  • Changed the way to get if the table has identity in MS SQL.
  • NCHAR/NVARCHAR and N''-quoted strings for MS SQL.

SQLObject 1.3.3

Released 26 May 2013.

  • Fixed bugs in pickling and unpickling (remove/restore a weak proxy to self, fixed cache handling).
  • Added an example of using SQLObject with web.py by Rhubarb Sin to the links page.

SQLObject 1.3.2

Released 20 Oct 2012.

SQLObject 1.3.1

Released 25 May 2012.

SQLObject 1.3.0

Released 31 Mar 2012.

Features & Interface

  • PostgresConnection performs translation of exceptions to standard SQLObject's hierarchy of exceptions.
  • Major update of FirebirdConnection: introspection was completely rewritten and extended; charset was renamed to dbEncoding; a longstanding bug was fixed - pass port to connect().

SQLObject 1.2.4

Released 20 Oct 2012.

  • Fixed a bug in sqlbuilder.Select.filter - removed comparison with SQLTrueClause.
  • Neil Muller fixed a number of tests.

SQLObject 1.2.3

Released 25 May 2012.

  • Fixed a minor bug in PostgreSQL introspection: VIEWs don't have PRIMARY KEYs - use sqlmeta.idName as the key.
  • Fixed a bug in cache handling while unpickling.

SQLObject 1.2.2

Released 1 Mar 2012.

SQLObject 1.2.1

Released 4 Dec 2011.

SQLObject 1.2.0

Released 20 Nov 2011.

Features & Interface

  • Strings are treated specially in Select to allow Select(['id, 'name'], where='value = 42'). Update allows a string in WHERE.
  • ForeignKey('Table', refColumn='refcol_id') to allow ForeignKey to point to a non-id column; the referred column must be a unique integer column.
  • delColumn now accepts a ForeignKey's name without 'ID'.
  • Support for PostgreSQL 7.* is dropped. The minimal supported version of PostgreSQL is 8.1 now.
  • Quoting rules changed for PostgreSQL: SQLObject uses E'' escape string if the string contains characters escaped with backslash.
  • A bug caused by psycopg2 recently added a new boolean not callable autocommit attribute was fixed.
  • sqlobject.__doc__ and main.__doc__ no longer contain version number. Use sqlobject.version or version_info.

SQLObject 1.1.5

Released 1 Mar 2012.

  • A bug was fixed in SQLiteConnection - clear _threadPool on close().

SQLObject 1.1.4

Released 4 Dec 2011.

  • A bug was fixed in handling modulo operator - SQLite implements only %, MySQL - only MOD(), PostgreSQL implements both.

SQLObject 1.1.3

Released 30 Aug 2011.

SQLObject 1.1.2

Released 8 Aug 2011.

SQLObject 1.1.1

Released 1 Jul 2011.

  • Parsing sqlobject.__doc__ for version number is declared obsolete. Use sqlobject.version or version_info.
  • Documented sqlmeta.dbEncoding and connection.dbEncoding.

SQLObject 1.1

Released 20 Jun 2011.

Features & Interface

  • SelectResults (returned from .select()) is allowed in IN(column, list).
  • A different workaround is used in SQLiteConnection to prevent PySQLite from converting strings to unicode - in the case of a registered text conversion function PySQLite silently converts empty strings to Nones; now SQLObject uses text_factory instead and properly returns empty strings.
  • It is now possible to declare one encoding for all UnicodeCol's per table (as sqlmeta.dbEncoding) or per connection (as connection.dbEncoding). Default (if dbEncoding is found neither in column nor in table nor in connection) is 'utf-8'.

Source code and internals

  • Decorators @classmethod and @staticmethod are used everywhere.
  • All 'mydict.has_key(name)' checks were replaced with 'name in mydict'.

SQLObject 1.0.3

Released 30 Aug 2011.

  • Fixed a bug with Postgres - add quotes in "SET client_encoding" query.

SQLObject 1.0.2

Released 8 Aug 2011.

  • A bug was fixed in SelectResults slicing that prevented to slice a slice (my_results[:20][1:5]).

SQLObject 1.0.1

Released 30 May 2011.

  • A syntax incompatibility was fixed in SQLiteConnection that prevented SQLObject to be used with Python 2.4.

SQLObject 1.0.0

Released 28 Mar 2011.

Features & Interface

  • Major API change: DB URI parser was changed to use urllib.split*() and unquote(). This means any username/password/path are allowed in DB URIs if they are properly %-encoded, and DB URIs are automatically unquoted.
  • A new module __version__.py was added. New variables version (string) and version_info (5-tuple: major, minor, micro, release level, serial) are imported into sqlobject namespace.
  • In SQLite, id columns are made AUTOINCREMENT.
  • Parameter backend in DB URI is no longer supported, use parameter driver.

Older news

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/Authors.html0000644000175000017500000000760212754657232017102 0ustar phdphd00000000000000 Authors

Authors

SQLObject was originally written by Ian Bicking <ianb@colorstudy.com>.

Contributions have been made by:

  • Frank Barknecht <fbar at footils.org>
  • Bud P. Bruegger <bug at sistema.it>
  • David M. Cook <dave at davidcook.org>
  • Luke Opperman <luke at metathusalan.com>
  • James Ralston <jralston at hotmail.com>
  • Sidnei da Silva <sidnei at awkly.org>
  • Brad Bollenbach <brad at bbnet.ca>
  • Daniel Savard, Xsoli Inc <sqlobject at xsoli.com>
  • alexander smishlajev <alex at ank-sia.com>
  • Yaroslav Samchuk <yarcat at ank-sia.com>
  • Runar Petursson <grunar at gmail.com>
  • J Paulo Fernandes Farias <jpaulofarias at gmail.com>
  • Shahms King <shahms at shahms.com>
  • David Turner, The Open Planning Project
  • Dan Pascu <dan at ag-projects.com>
  • Diez B. Roggisch <deets at web.de>
  • Christopher Singley <csingley at gmail.com>
  • David Keeney <dkeeney at rdbhost.com>
  • Daniel Fetchinson <fetchinson at googlemail.com>
  • Neil Muller <drnlmuller+sqlobject at gmail.com>
  • Petr Jakes <petr.jakes at tpc.cz>
  • Ken Lalonde
  • Andrew Ziem <ahz001 at gmail.com>
  • Andrew Trusty <atrusty at gatech.edu>
  • Ian Cordasco <graffatcolmingov at gmail.com>
  • Lukasz Dobrzanski <lukasz.m.dobrzanski at gmail.com>
  • Gregor Horvath <gh at gregor-horvath.com>
  • Nathan Edwards <nje5 at georgetown.edu>
  • Lutz Steinborn <l.steinborn at 4c-gmbh.de>
  • Oleg Broytman <phd@phdru.name>
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.col.html0000644000175000017500000010356412754657345021513 0ustar phdphd00000000000000

col

Col -- SQLObject columns

The col module is accessible via the sqlobject module.

Note that each column object is named BlahBlahCol, and these are used in class definitions. But there's also a corresponding SOBlahBlahCol object, which is used in SQLObject classes.

An explanation: when a SQLObject subclass is created, the metaclass looks through your class definition for any subclasses of Col. It collects them together, and indexes them to do all the database stuff you like, like the magic attributes and whatnot. It then asks the Col object to create an SOCol object (usually a subclass, actually). The SOCol object contains all the interesting logic, as well as a record of the attribute name you used and the class it is bound to (set by the metaclass).

So, in summary: Col objects are what you define, but SOCol objects are what gets used.

Attributes

a DATETIME_IMPLEMENTATION

'datetime'

a mxdatetime_available

True

a MXDATETIME_IMPLEMENTATION

'mxDateTime'

a datetime_available

True

a __package__

'sqlobject'

a default_datetime_implementation

'datetime'

Functions

f use_microseconds(use=True) ...

Classes

C SOCol(...) ...

This class contains 21 members.

C Col(...) ...

This class contains 7 members.

C SOStringLikeCol(...) ...

A common ancestor for SOStringCol and SOUnicodeCol

This class contains 21 members.

C SOStringCol(...) ...

This class contains 21 members.

C StringCol(...) ...

This class contains 7 members.

C SOUnicodeCol(...) ...

This class contains 21 members.

C UnicodeCol(...) ...

This class contains 7 members.

C SOIntCol(...) ...

This class contains 22 members.

C IntCol(...) ...

This class contains 7 members.

C SOTinyIntCol(...) ...

This class contains 22 members.

C TinyIntCol(...) ...

This class contains 7 members.

C SOSmallIntCol(...) ...

This class contains 22 members.

C SmallIntCol(...) ...

This class contains 7 members.

C SOMediumIntCol(...) ...

This class contains 22 members.

C MediumIntCol(...) ...

This class contains 7 members.

C SOBigIntCol(...) ...

This class contains 22 members.

C BigIntCol(...) ...

This class contains 7 members.

C SOBoolCol(...) ...

This class contains 21 members.

C BoolCol(...) ...

This class contains 7 members.

C SOFloatCol(...) ...

This class contains 21 members.

C FloatCol(...) ...

This class contains 7 members.

C SOKeyCol(...) ...

This class contains 22 members.

C KeyCol(...) ...

This class contains 7 members.

C SOForeignKey(...) ...

This class contains 27 members.

C ForeignKey(...) ...

This class contains 7 members.

C SOEnumCol(...) ...

This class contains 21 members.

C EnumCol(...) ...

This class contains 7 members.

C SOSetCol(...) ...

This class contains 21 members.

C SetCol(...) ...

This class contains 7 members.

C SODateTimeCol(...) ...

This class contains 22 members.

C DateTimeCol(...) ...

This class contains 8 members.

C SODateCol(...) ...

This class contains 22 members.

C DateCol(...) ...

This class contains 7 members.

C SOTimeCol(...) ...

This class contains 22 members.

C TimeCol(...) ...

This class contains 7 members.

C SOTimestampCol(...) ...

Necessary to support MySQL's use of TIMESTAMP versus DATETIME types

This class contains 22 members.

C TimestampCol(...) ...

This class contains 7 members.

C SOTimedeltaCol(...) ...

This class contains 21 members.

C TimedeltaCol(...) ...

This class contains 7 members.

C SODecimalCol(...) ...

This class contains 21 members.

C DecimalCol(...) ...

This class contains 7 members.

C SOCurrencyCol(...) ...

This class contains 21 members.

C CurrencyCol(...) ...

This class contains 7 members.

C SODecimalStringCol(...) ...

This class contains 21 members.

C DecimalStringCol(...) ...

This class contains 7 members.

C SOBLOBCol(...) ...

This class contains 21 members.

C BLOBCol(...) ...

This class contains 7 members.

C SOPickleCol(...) ...

This class contains 21 members.

C PickleCol(...) ...

This class contains 7 members.

C SOUuidCol(...) ...

This class contains 21 members.

C UuidCol(...) ...

This class contains 7 members.

C SOJsonbCol(...) ...

This class contains 21 members.

C JsonbCol(...) ...

This class contains 7 members.

C SOJSONCol(...) ...

This class contains 21 members.

C JSONCol(...) ...

This class contains 7 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.constraints.InList.html0000644000175000017500000000351212754657323024312 0ustar phdphd00000000000000

InList

The InList class is accessible via the sqlobject.constraints module.

Methods

f __init__(self, l) ...

f __call__(self, obj, col, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLJoinOn.html0000644000175000017500000004053112754657331024464 0ustar phdphd00000000000000

SQLJoinOn

Conditional JOIN ON

The SQLJoinOn class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __sqlrepr__(self, db) ...

f __init__(self, table1, table2, op, on_condition) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Outer.html0000644000175000017500000000266712754657326024022 0ustar phdphd00000000000000

Outer

The Outer class is accessible via the sqlobject.sqlbuilder module.

Methods

f __init__(self, table) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sqlite.sqliteconnection.html0000644000175000017500000000570412754657336025614 0ustar phdphd00000000000000

sqliteconnection

The sqliteconnection module is accessible via the sqlobject.sqlite module.

Attributes

a __package__

'sqlobject.sqlite'

Classes

C ErrorMessage(...) ...

This class contains 20 members.

C SQLiteConnection(...) ...

This class contains 27 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.DropTableSignal.html0000644000175000017500000000730412754657341025062 0ustar phdphd00000000000000

DropTableSignal

Called when a table is dropped. If ifExists==True and the table doesn't exist, this event is not called.

The DropTableSignal class is accessible via the sqlobject.events module.

Called with (cls, connection, extra_sql, post_funcs). post_funcs functions are called with (cls, connection) after the table has been dropped.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Replace.html0000644000175000017500000004125512754657330024266 0ustar phdphd00000000000000

Replace

The Replace class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table, values, template=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, where=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>) ...

f __sqlrepr__(self, db) ...

f sqlName(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sqlbuilder.html0000644000175000017500000016070712754657325023104 0ustar phdphd00000000000000

sqlbuilder

The sqlbuilder module is accessible via the sqlobject module.

Builds SQL expressions from normal Python expressions.

Disclaimer

This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.

Instructions

To begin a SQL expression, you must use some sort of SQL object -- a field, table, or SQL statement (SELECT, INSERT, etc.) You can then use normal operators, with the exception of: and , or , not , and in . You can use the AND , OR , NOT , and IN functions instead, or you can also use & , | , and ~ for and , or , and not respectively (however -- the precidence for these operators doesn't work as you would want, so you must use many parenthesis).

To create a sql field, table, or constant/function, use the namespaces table , const , and func . For instance, table.address refers to the address table, and table.address.state refers to the state field in the address table. const.NULL is the NULL SQL constant, and func.NOW() is the NOW() function call ( const and func are actually identicle, but the two names are provided for clarity). Once you create this object, expressions formed with it will produce SQL statements.

The sqlrepr(obj) function gets the SQL representation of these objects, as well as the proper SQL representation of basic Python types (None==NULL).

There are a number of DB-specific SQL features that this does not implement. There are a bunch of normal ANSI features also not present.

See the bottom of this module for some examples, and run it (i.e. python sql.py) to see the results of those examples.

Attributes

a PY2

True

a const

<sqlobject.sqlbuilder.ConstantSpace instance at 0xb6749c6c>

a table

<sqlobject.sqlbuilder.TableSpace instance at 0xb67496ec>

a SQLTrueClause

1 = 1

a func

<sqlobject.sqlbuilder.ConstantSpace instance at 0xb6749c6c>

a operatorMap

{'!=': <built-in function ne>,
 '*': <built-in function mul>,
 '+': <built-in function add>,
 '-': <built-in function sub>,
 '/': <built-in function div>,
 '<': <built-in function lt>,
 '<=': <built-in function le>,
 '=': <built-in function eq>,
 '>': <built-in function gt>,
 '>=': <built-in function ge>,
 'IN': <built-in function contains>,
 'IS': <built-in function eq>}

a safeSQLRE

<_sre.SRE_Pattern object at 0xb664a278>

a __package__

'sqlobject'

Functions

f sqlIdentifier(obj) ...

f execute(expr, executor) ...

f SQLExprConverter(value, db) ...

f tablesUsedSet(obj, db) ...

f dictToList(template, dict) ...

f AND(*ops) ...

f OR(*ops) ...

f NOT(op) ...

f IN(item, list) ...

f NOTIN(item, list) ...

f STARTSWITH(expr, pattern) ...

f ENDSWITH(expr, pattern) ...

f CONTAINSSTRING(expr, pattern) ...

f ISNULL(expr) ...

f ISNOTNULL(expr) ...

f JOIN(table1, table2) ...

f INNERJOIN(table1, table2) ...

f CROSSJOIN(table1, table2) ...

f STRAIGHTJOIN(table1, table2) ...

f LEFTJOIN(table1, table2) ...

f LEFTOUTERJOIN(table1, table2) ...

f NATURALJOIN(table1, table2) ...

f NATURALLEFTJOIN(table1, table2) ...

f NATURALLEFTOUTERJOIN(table1, table2) ...

f RIGHTJOIN(table1, table2) ...

f RIGHTOUTERJOIN(table1, table2) ...

f NATURALRIGHTJOIN(table1, table2) ...

f NATURALRIGHTOUTERJOIN(table1, table2) ...

f FULLJOIN(table1, table2) ...

f FULLOUTERJOIN(table1, table2) ...

f NATURALFULLJOIN(table1, table2) ...

f NATURALFULLOUTERJOIN(table1, table2) ...

f INNERJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f LEFTJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f LEFTOUTERJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f RIGHTJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f RIGHTOUTERJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f FULLJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f FULLOUTERJOINConditional(table1, table2, on_condition=None, using_columns=None) ...

f INNERJOINOn(table1, table2, on_condition) ...

f LEFTJOINOn(table1, table2, on_condition) ...

f LEFTOUTERJOINOn(table1, table2, on_condition) ...

f RIGHTJOINOn(table1, table2, on_condition) ...

f RIGHTOUTERJOINOn(table1, table2, on_condition) ...

f FULLJOINOn(table1, table2, on_condition) ...

f FULLOUTERJOINOn(table1, table2, on_condition) ...

f INNERJOINUsing(table1, table2, using_columns) ...

f LEFTJOINUsing(table1, table2, using_columns) ...

f LEFTOUTERJOINUsing(table1, table2, using_columns) ...

f RIGHTJOINUsing(table1, table2, using_columns) ...

f RIGHTOUTERJOINUsing(table1, table2, using_columns) ...

f FULLJOINUsing(table1, table2, using_columns) ...

f FULLOUTERJOINUsing(table1, table2, using_columns) ...

f EXISTS(subquery) ...

f NOTEXISTS(subquery) ...

f SOME(subquery) ...

f ANY(subquery) ...

f ALL(subquery) ...

Classes

C VersionError(...) ...

This class contains 10 members.

C NoDefault(...) ...

C SQLObjectState(...) ...

This class contains 4 members.

C SQLExpression(...) ...

This class contains 36 members.

C SQLOp(...) ...

This class contains 39 members.

C SQLModulo(...) ...

This class contains 39 members.

C SQLCall(...) ...

This class contains 39 members.

C SQLPrefix(...) ...

This class contains 39 members.

C SQLConstant(...) ...

This class contains 39 members.

C SQLTrueClauseClass(...) ...

This class contains 38 members.

C Field(...) ...

This class contains 39 members.

C SQLObjectField(...) ...

This class contains 39 members.

C Table(...) ...

This class contains 40 members.

C SQLObjectTable(...) ...

This class contains 40 members.

C SQLObjectTableWithJoins(...) ...

This class contains 40 members.

C TableSpace(...) ...

This class contains 1 member.

C ConstantSpace(...) ...

C AliasField(...) ...

This class contains 39 members.

C AliasTable(...) ...

This class contains 41 members.

C Alias(...) ...

This class contains 38 members.

C Union(...) ...

This class contains 38 members.

C Select(...) ...

This class contains 48 members.

C Insert(...) ...

This class contains 38 members.

C Update(...) ...

This class contains 39 members.

C Delete(...) ...

To be safe, this will signal an error if there is no where clause, unless you pass in where=None to the constructor.

This class contains 38 members.

C Replace(...) ...

This class contains 39 members.

C DESC(...) ...

This class contains 38 members.

C ColumnAS(...) ...

Just like SQLOp('AS', expr, name) except without the parentheses

This class contains 39 members.

C CONCAT(...) ...

This class contains 38 members.

C SQLJoin(...) ...

This class contains 38 members.

C SQLJoinConditional(...) ...

Conditional JOIN

This class contains 38 members.

C SQLJoinOn(...) ...

Conditional JOIN ON

This class contains 38 members.

C SQLJoinUsing(...) ...

Conditional JOIN USING

This class contains 38 members.

C OuterField(...) ...

This class contains 39 members.

C OuterTable(...) ...

This class contains 40 members.

C Outer(...) ...

This class contains 1 member.

C LIKE(...) ...

This class contains 40 members.

C RLIKE(...) ...

This class contains 41 members.

C INSubquery(...) ...

This class contains 39 members.

C NOTINSubquery(...) ...

This class contains 39 members.

C Subquery(...) ...

This class contains 38 members.

C ImportProxyField(...) ...

This class contains 39 members.

C ImportProxy(...) ...

Class to be used in column definitions that rely on other tables that might not yet be in a classregistry.

This class contains 39 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.maxdb.maxdbconnection.PrimaryKeyNotFounded.html0000644000175000017500000001364112754657343031076 0ustar phdphd00000000000000

PrimaryKeyNotFounded

The PrimaryKeyNotFounded class is accessible via the sqlobject.maxdb.maxdbconnection module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, value) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.Command.html0000644000175000017500000003336512754657314025157 0ustar phdphd00000000000000

Command

The Command class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

''

a aliases

()

a max_args

0

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f command(self) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.firebird.firebirdconnection.html0000644000175000017500000000463112754657333026361 0ustar phdphd00000000000000

firebirdconnection

The firebirdconnection module is accessible via the sqlobject.firebird module.

Attributes

a __package__

'sqlobject.firebird'

Classes

C FirebirdConnection(...) ...

This class contains 22 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.firebird.firebirdconnection.FirebirdConnection.html0000644000175000017500000002662412754657333031754 0ustar phdphd00000000000000

FirebirdConnection

The FirebirdConnection class is accessible via the sqlobject.firebird.firebirdconnection module.

Attributes

a supportTransactions

False

a limit_re

<_sre.SRE_Pattern object at 0xb6540930>

a schemes

['firebird']

a dbName

'firebird'

Methods

f __init__(self, host, db, port='3050', user='sysdba', password='masterkey', autoCommit=1, dialect=None, role=None, charset=None, **kw) ...

f makeConnection(self) ...

f createTable(self, soClass) ...

f createReferenceConstraint(self, soClass, col) ...

f createColumn(self, soClass, col) ...

f createIDColumn(self, soClass) ...

f createIndexSQL(self, soClass, index) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f addColumn(self, tableName, column) ...

f dropTable(self, tableName, cascade=False) ...

f delColumn(self, sqlmeta, column) ...

f readDefaultEncodingFromDB(self) ...

f columnsFromSchema(self, tableName, soClass) ...

Look at the given table and create Col instances (or subclasses of Col) for the fields it finds in that table.

f guessClass(self, t, flength, fCharset, fscale=None) ...

An internal method that tries to figure out what Col subclass is appropriate given whatever introspective information is available -- both very database-specific.

f createEmptyDatabase(self) ...

f dropDatabase(self) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.util.csvexport.html0000644000175000017500000001335212754657321023734 0ustar phdphd00000000000000

csvexport

Exports a SQLObject class (possibly annotated) to a CSV file.

The csvexport module is accessible via the sqlobject.util module.

Attributes

a __package__

'sqlobject.util'

Functions

f export_csv(soClass, select=None, writer=None, connection=None, orderBy=None) ...

Export the SQLObject class soClass to a CSV file.

soClass can also be a SelectResult object, as returned by .select(). If it is a class, all objects will be retrieved, ordered by orderBy if given, or the .csvOrderBy attribute if present (but csvOrderBy will only be applied when no select result is given).

You can also pass in select results (or simply a list of instances) in select -- if you have a list of objects (not a SelectResult instance, as produced by .select()) then you must pass it in with select and pass the class in as the first argument.

writer is a csv.writer() object, or a file-like object. If not given, the string of the file will be returned.

Uses connection as the data source, if given, otherwise the default connection.

Columns can be annotated with .csvTitle attributes, which will form the attributes of the columns, or 'title' (secondarily), or if nothing then the column attribute name.

If a column has a .noCSV attribute which is true, then the column will be suppressed.

Additionally a class can have an .extraCSVColumns attribute, which should be a list of strings/tuples. If a tuple, it should be like (attribute, title), otherwise it is the attribute, which will also be the title. These will be appended to the end of the CSV file; the attribute will be retrieved from instances.

Also a .csvColumnOrder attribute can be on the class, which is the string names of attributes in the order they should be presented.

f export_csv_zip(soClasses, file=None, zip=None, filename_prefix='', connection=None) ...

Export several SQLObject classes into a .zip file. Each item in the soClasses list may be a SQLObject class, select result, or (soClass, select) tuple.

Each file in the zip will be named after the class name (with .csv appended), or using the filename in the .csvFilename attribute.

If file is given, the zip will be written to that. file may be a string (a filename) or a file-like object. If not given, a string will be returnd.

If zip is given, then the files will be written to that zip file.

All filenames will be prefixed with filename_prefix (which may be a directory name, for instance).

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.converters.ConverterRegistry.html0000644000175000017500000000450212754657334026435 0ustar phdphd00000000000000

ConverterRegistry

The ConverterRegistry class is accessible via the sqlobject.converters module.

Methods

f __init__(self) ...

f registerConverter(self, typ, func) ...

f lookupConverter(self, value, default=None) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.cache.CacheSet.html0000644000175000017500000002146712754657316023276 0ustar phdphd00000000000000

CacheSet

A CacheSet is used to collect and maintain a series of caches. In SQLObject, there is one CacheSet per connection, and one Cache in the CacheSet for each class, since IDs are not unique across classes. It contains methods similar to Cache, but that take a cls argument.

The CacheSet class is accessible via the sqlobject.cache module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, *args, **kw) ...

f get(self, id, cls) ...

f put(self, id, cls, obj) ...

f finishPut(self, cls) ...

f created(self, id, cls, obj) ...

f expire(self, id, cls) ...

f clear(self, cls=None) ...

f tryGet(self, id, cls) ...

f tryGetByName(self, id, clsname) ...

f allIDs(self, cls) ...

f allSubCaches(self) ...

f allSubCachesByClassNames(self) ...

f weakrefAll(self, cls=None) ...

Move all objects in the cls (or if not given, then in all classes) to the weakref dictionary, where they can be collected.

f getAll(self, cls=None) ...

Returns all instances in the cache for the given class or all classes.

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.declarative-index.html0000644000175000017500000001764112754657343024324 0ustar phdphd00000000000000 Index of sqlobject.declarative module

Index of the declarative module

SQLObject-3.1.0/docs/html/class-sqlobject.mysql.mysqlconnection.MySQLConnection.html0000644000175000017500000002522112754657316030122 0ustar phdphd00000000000000

MySQLConnection

The MySQLConnection class is accessible via the sqlobject.mysql.mysqlconnection module.

Attributes

a supportTransactions

False

a schemes

['mysql']

a dbName

'mysql'

Methods

f __init__(self, db, user, password='', host='localhost', port=0, **kw) ...

f makeConnection(self) ...

f createReferenceConstraint(self, soClass, col) ...

f createColumn(self, soClass, col) ...

f createIndexSQL(self, soClass, index) ...

f createIDColumn(self, soClass) ...

f joinSQLType(self, join) ...

f tableExists(self, tableName) ...

f addColumn(self, tableName, column) ...

f delColumn(self, sqlmeta, column) ...

f columnsFromSchema(self, tableName, soClass) ...

f guessClass(self, t) ...

f listTables(self) ...

f listDatabases(self) ...

f createEmptyDatabase(self) ...

f dropDatabase(self) ...

f server_version(self) ...

f can_use_microseconds(self) ...

f __del__(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.OuterTable.html0000644000175000017500000004126212754657331024760 0ustar phdphd00000000000000

OuterTable

The OuterTable class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __sqlrepr__(self, db) ...

f execute(self, executor) ...

f __init__(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.maxdb.maxdbconnection-index.html0000644000175000017500000003052412754657343026301 0ustar phdphd00000000000000 Index of sqlobject.maxdb.maxdbconnection module

Index of the maxdbconnection module

SQLObject-3.1.0/docs/html/module-sqlobject.postgres.pgconnection-index.html0000644000175000017500000002251112754657320026357 0ustar phdphd00000000000000 Index of sqlobject.postgres.pgconnection module

Index of the pgconnection module

SQLObject-3.1.0/docs/html/module-sqlobject.util.threadinglocal.html0000644000175000017500000000325412754657321024657 0ustar phdphd00000000000000

threadinglocal

The threadinglocal module is accessible via the sqlobject.util module.

Attributes

a __package__

'sqlobject.util'

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOFloatCol.html0000644000175000017500000002453312754657347023277 0ustar phdphd00000000000000

SOFloatCol

The SOFloatCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, name, soClass, creationOrder, dbName=None, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, notNone=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, unique=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f autoConstraints(self) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SetCol.html0000644000175000017500000000747212754657347022526 0ustar phdphd00000000000000

SetCol

The SetCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOKeyCol.html0000644000175000017500000002422312754657352022752 0ustar phdphd00000000000000

SOKeyCol

The SOKeyCol class is accessible via the sqlobject.col module.

Attributes

a key_type

{<type 'int'>: 'INT', <type 'str'>: 'TEXT'}

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createValidators(self) ...

Create a list of validators for the column.

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.styles.DefaultStyle.html0000644000175000017500000001720212754657336024476 0ustar phdphd00000000000000

DefaultStyle

This is the default style. Python attributes use mixedCase, while database columns use underscore_separated.

The DefaultStyle class is accessible via the sqlobject.styles module.

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, pythonAttrToDBColumn=None, dbColumnToPythonAttr=None, pythonClassToDBTable=None, dbTableToPythonClass=None, idForTable=None, longID=False) ...

f idForTable(self, table) ...

f pythonClassToAttr(self, className) ...

f instanceAttrToIDAttr(self, attr) ...

f instanceIDAttrToAttr(self, attr) ...

f pythonAttrToDBColumn(self, attr) ...

f dbColumnToPythonAttr(self, col) ...

f pythonClassToDBTable(self, className) ...

f dbTableToPythonClass(self, table) ...

f pythonClassToDBTableReference(self, className) ...

f tableReference(self, table) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.declarative.html0000644000175000017500000001226712754657343023216 0ustar phdphd00000000000000

declarative

Declarative objects.

The declarative module is accessible via the sqlobject module.

Declarative objects have a simple protocol: you can use classes in lieu of instances and they are equivalent, and any keyword arguments you give to the constructor will override those instance variables. (So if a class is received, we'll simply instantiate an instance with no arguments).

You can provide a variable __unpackargs__ (a list of strings), and if the constructor is called with non-keyword arguments they will be interpreted as the given keyword arguments.

If __unpackargs__ is ('*', name), then all the arguments will be put in a variable by that name.

You can define a __classinit__(cls, new_attrs) method, which will be called when the class is created (including subclasses). Note: you can't use super() in __classinit__ because the class isn't bound to a name. As an analog to __classinit__, Declarative adds __instanceinit__ which is called with the same argument (new_attrs). This is like __init__, but after __unpackargs__ and other factors have been taken into account.

If __mutableattributes__ is defined as a sequence of strings, these attributes will not be shared between superclasses and their subclasses. E.g., if you have a class variable that contains a list and you append to that list, changes to subclasses will effect superclasses unless you add the attribute here.

Also defines classinstancemethod, which acts as either a class method or an instance method depending on where it is called.

Attributes

a __package__

'sqlobject'

Classes

C classinstancemethod(...) ...

Acts like a class method when called from a class, like an instance method when called by an instance. The method should take two arguments, 'self' and 'cls'; one of these will be None depending on how the method was called.

This class contains 5 members.

C DeclarativeMeta(...) ...

This class contains 23 members.

C Declarative(...) ...

This class contains 12 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.TimedeltaCol.html0000644000175000017500000000755212754657347023702 0ustar phdphd00000000000000

TimedeltaCol

The TimedeltaCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.LogWriter.html0000644000175000017500000000354612754657340025132 0ustar phdphd00000000000000

LogWriter

The LogWriter class is accessible via the sqlobject.dbconnection module.

Methods

f __init__(self, connection, logger, loglevel) ...

f write(self, text) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.joins.SQLMultipleJoin.html0000644000175000017500000001040412754657353024657 0ustar phdphd00000000000000

SQLMultipleJoin

The SQLMultipleJoin class is accessible via the sqlobject.joins module.

Attributes

a joinMethodName

<property object at 0xb65c6c0c>

a name

<property object at 0xb65c6c0c>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, otherClass=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.declarative.Declarative.html0000644000175000017500000001430412754657344025253 0ustar phdphd00000000000000

Declarative

The Declarative class is accessible via the sqlobject.declarative module.

Attributes

a __unpackargs__

()

a singleton

<bound class method Declarative.singleton>

a __mutableattributes__

()

a __restrict_attributes__

None

a declarative_count

0

Methods

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __format__(...) ...

default object formatter

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __classinit__(cls, new_attrs) ...

f __instanceinit__(self, new_attrs) ...

f __init__(self, *args, **kw) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Delete.html0000644000175000017500000004053112754657330024111 0ustar phdphd00000000000000

Delete

To be safe, this will signal an error if there is no where clause, unless you pass in where=None to the constructor.

The Delete class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table, where=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOForeignKey.html0000644000175000017500000003066312754657350023631 0ustar phdphd00000000000000

SOForeignKey

The SOForeignKey class is accessible via the sqlobject.col module.

Attributes

a key_type

{<type 'int'>: 'INT', <type 'str'>: 'TEXT'}

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f firebirdCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f createValidators(self) ...

f sqliteCreateSQL(self) ...

f postgresCreateSQL(self) ...

f postgresCreateReferenceConstraint(self) ...

f mysqlCreateReferenceConstraint(self) ...

f mysqlCreateSQL(self, connection=None) ...

f sybaseCreateSQL(self) ...

f sybaseCreateReferenceConstraint(self) ...

f mssqlCreateSQL(self, connection=None) ...

f mssqlCreateReferenceConstraint(self) ...

f maxdbCreateSQL(self) ...

f maxdbCreateReferenceConstraint(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.firebird.html0000644000175000017500000000467412754657333022523 0ustar phdphd00000000000000

firebird

The firebird module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.firebird'

Functions

f builder() ...

Modules

The sqlobject.firebird module exposes 1 submodules:

firebirdconnection

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.util.moduleloader-index.html0000644000175000017500000000556712754657321025471 0ustar phdphd00000000000000 Index of sqlobject.util.moduleloader module

Index of the moduleloader module

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.CONCAT.html0000644000175000017500000004020112754657332023652 0ustar phdphd00000000000000

CONCAT

The CONCAT class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, *expressions) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.cache-index.html0000644000175000017500000002224412754657316023077 0ustar phdphd00000000000000 Index of sqlobject.cache module

Index of the cache module

  • m sqlobject.cache ... - This implements the instance caching in SQLObject. Caching is relatively aggressive. All objects are retained so long as they are in memory, by keeping weak references to objects. We also keep other objects in a cache that doesn't allow them to be garbage collected (unless caching is turned off).
    • a __package__ ...
    • C CacheFactory ... - CacheFactory caches object creation. Each object should be referenced by a single hashable ID (note tuples of hashable values are also hashable).
      • f cull ... - Runs through the cache and expires objects
      • f getAll ... - Return all the objects in the cache.
      • f finishPut ... - Releases the lock that is retained when .get() is called and returns None.
      • f created ... - Inserts and object into the cache. Should be used when no one else knows about the object yet, so there cannot be any object already in the cache. After a database INSERT is an example of this situation.
      • f clear ... - Removes everything from the cache. Warning! This can cause duplicate objects in memory.
      • f expireAll ... - Expires all objects, moving them all into the expired/weakref cache.
      • f tryGet ... - This returns None, or the object in cache.
      • f get ... - This method can cause deadlocks! tryGet is safer
      • f expire ... - Expires a single object. Typically called after a delete. Doesn't even keep a weakref. (@@: bad name?)
      • f put ... - Puts an object into the cache. Should only be called after .get(), so that duplicate objects don't end up in the cache.
      • f allIDs ... - Returns the IDs of all objects in the cache.
      • f __init__ ... - Every cullFrequency times that an item is retrieved from this cache, the cull method is called.
    • C CacheSet ... - A CacheSet is used to collect and maintain a series of caches. In SQLObject, there is one CacheSet per connection, and one Cache in the CacheSet for each class, since IDs are not unique across classes. It contains methods similar to Cache, but that take a cls argument.
SQLObject-3.1.0/docs/html/class-sqlobject.joins.MultipleJoin.html0000644000175000017500000001035112754657352024277 0ustar phdphd00000000000000

MultipleJoin

The MultipleJoin class is accessible via the sqlobject.joins module.

Attributes

a joinMethodName

<property object at 0xb65c6c0c>

a name

<property object at 0xb65c6c0c>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, otherClass=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.manager.command.CommandExecute.html0000644000175000017500000003706312754657313026500 0ustar phdphd00000000000000

CommandExecute

The CommandExecute class is accessible via the sqlobject.manager.command module.

Attributes

a min_args

0

a help

'Runs SQL statements directly in the database, with no intervention.  Useful when used with a configuration file.  Each argument is executed as an individual statement.'

a parser

<optparse.OptionParser instance at 0xb64e756c>

a aliases

()

a max_args

None

a max_args_error

'You must provide no more than %(max_args)s arguments'

a description

None

a prog_name

<property object at 0xb64c50f4>

a name

'execute'

a summary

'Execute SQL statements'

a min_args_error

'You must provide at least %(min_args)s arguments'

a required_args

[]

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f orderClassesByDependencyLevel(self, classes) ...

Return classes ordered by their depth in the class dependency tree (this is not the inheritance tree), from the top level (independant) classes to the deepest level. The dependency tree is defined by the foreign key relations.

f __classinit__(cls, new_args) ...

f __init__(self, invoked_as, command_name, args, runner) ...

f run(self) ...

f classes(self, require_connection=True, require_some=False) ...

f classes_from_module(self, module) ...

f connection(self) ...

f config(self) ...

f ini_config(self, conf_fn) ...

f classes_from_package(self, package_name) ...

f classes_from_egg(self, egg_spec) ...

f load_options_from_egg(self, egg_spec) ...

f config_from_egg(self, egg_spec, warn_no_sqlobject=True) ...

f ask(self, prompt, safe=False, default=True) ...

f shorten_filename(self, fn) ...

Shortens a filename to make it relative to the current directory (if it can). For display purposes.

f open_editor(self, pretext, breaker=None, extension='.txt') ...

Open an editor with the given text. Return the new text, or None if no edits were made. If given, everything after breaker will be ignored.

f command(self) ...

f execute_sql(self, sql) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOTimeCol.html0000644000175000017500000002407412754657350023122 0ustar phdphd00000000000000

SOTimeCol

The SOTimeCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a timeFormat

'%H:%M:%S.%f'

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.util.html0000644000175000017500000000474312754657321021704 0ustar phdphd00000000000000

util

The util module is accessible via the sqlobject module.

Attributes

a __package__

None

Modules

The sqlobject.util module exposes 4 submodules:

csvexport
Exports a SQLObject class (possibly annotated) to a CSV file.
csvimport
Import from a CSV file or directory of files.
moduleloader
threadinglocal

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.postgres.pgconnection.ErrorMessage.html0000644000175000017500000002527412754657320027500 0ustar phdphd00000000000000

ErrorMessage

The ErrorMessage class is accessible via the sqlobject.postgres.pgconnection module.

Methods

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __rmod__(...) ...

x.__rmod__(y) <==> y%x

f __rmul__(...) ...

x.__rmul__(n) <==> n*x

f __sizeof__(...) ...

S.__sizeof__() -> size of S in memory, in bytes

f __getnewargs__(...) ...

f __lt__(...) ...

x.__lt__(y) <==> x<y

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

f __contains__(...) ...

x.__contains__(y) <==> y in x

f __format__(...) ...

S.__format__(format_spec) -> string

Return a formatted version of S as described by format_spec.

f __len__(...) ...

x.__len__() <==> len(x)

f __ne__(...) ...

x.__ne__(y) <==> x!=y

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __add__(...) ...

x.__add__(y) <==> x+y

f __gt__(...) ...

x.__gt__(y) <==> x>y

f __eq__(...) ...

x.__eq__(y) <==> x==y

f __mod__(...) ...

x.__mod__(y) <==> x%y

f __le__(...) ...

x.__le__(y) <==> x<=y

f __mul__(...) ...

x.__mul__(n) <==> x*n

f __ge__(...) ...

x.__ge__(y) <==> x>=y

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sqlite.html0000644000175000017500000000464012754657336022232 0ustar phdphd00000000000000

sqlite

The sqlite module is accessible via the sqlobject module.

Attributes

a __package__

'sqlobject.sqlite'

Functions

f builder() ...

Modules

The sqlobject.sqlite module exposes 1 submodules:

sqliteconnection

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Union.html0000644000175000017500000004010712754657326024003 0ustar phdphd00000000000000

Union

The Union class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, *tables) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOTimestampCol.html0000644000175000017500000002450512754657351024167 0ustar phdphd00000000000000

SOTimestampCol

Necessary to support MySQL's use of TIMESTAMP versus DATETIME types

The SOTimestampCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

a datetimeFormat

'%Y-%m-%d %H:%M:%S.%f'

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f createValidators(self) ...

f __init__(self, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.joins-index.html0000644000175000017500000004142112754657352023154 0ustar phdphd00000000000000 Index of sqlobject.joins module

Index of the joins module

SQLObject-3.1.0/docs/html/module-sqlobject.views-index.html0000644000175000017500000001221612754657321023163 0ustar phdphd00000000000000 Index of sqlobject.views module

Index of the views module

SQLObject-3.1.0/docs/html/module-sqlobject.postgres.pgconnection.html0000644000175000017500000000667312754657320025265 0ustar phdphd00000000000000

pgconnection

The pgconnection module is accessible via the sqlobject.postgres module.

Attributes

a __package__

'sqlobject.postgres'

Functions

f PsycoBinaryConverter(value, db) ...

Classes

C ErrorMessage(...) ...

This class contains 20 members.

C PostgresConnection(...) ...

This class contains 22 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOPickleCol.html0000644000175000017500000002344412754657350023433 0ustar phdphd00000000000000

SOPickleCol

The SOPickleCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f autoConstraints(self) ...

f __init__(self, **kw) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/DeveloperGuide.html0000644000175000017500000004263612754657232020366 0ustar phdphd00000000000000 SQLObject Developer Guide

SQLObject Developer Guide

These are some notes on developing SQLObject.

Development Installation

First install FormEncode:

$ git clone git://github.com/formencode/formencode.git
$ cd formencode
$ sudo python setup.py develop

Then do the same for SQLObject:

$ git clone git clone git://github.com/sqlobject/sqlobject
$ cd sqlobject
$ sudo python setup.py develop

Or rather fork it and clone your fork. To develop a feature or a bugfix create a separate branch, push it to your fork and create a pull request to the original repo. That way CI will be triggered to test your code.

Voila! The packages are globally installed, but the files from the checkout were not copied into site-packages. See setuptools for more.

Architecture

There are three main kinds of objects in SQLObject: tables, columns and connections.

Tables-related objects are in sqlobject/main.py module. There are two main classes: SQLObject and sqlmeta; the latter is not a metaclass but a parent class for sqlmeta attribute in every class - the authors tried to move there all attributes and methods not directly related to columns to avoid cluttering table namespace.

Connections are instances of DBConnection class (from sqlobject/dbconnection.py) and its concrete descendants. DBConnection contains generic code for generating SQL, working with transactions and so on. Concrete connection classes (like PostgresConnection and SQLiteConnection) provide backend-specific functionality.

Columns, validators and converters

Columns are instances of classes from sqlobject/col.py. There are two classes for every column: one is for user to include into an instance of SQLObject, an instance of the other is automatically created by SQLObject's metaclass. The two classes are usually named Col and SOCol; for example, BoolCol and SOBoolCol. User-visible classes, descendants of Col, seldom contain any code; the main code for a column is in SOCol descendants and in validators.

Every column has a list of validators. Validators validate input data and convert input data to python data and back. Every validator must have methods from_python and to_python. The former converts data from python to internal representation that will be converted by converters to SQL strings. The latter converts data from SQL data to python. Also please bear in mind that validators can receive None (for SQL NULL) and SQLExpression (an object that represents SQLObject expressions); both objects must be passed unchanged by validators.

Converters from sqlobject/converters.py aren't visible to users. They are used behind the scene to convert objects returned by validators to backend-specific SQL strings. The most elaborated converter is StringLikeConverter. Yes, it converts strings to strings. It converts python strings to SQL strings using backend-specific quoting rules.

Let look into BoolCol as an example. The very BoolCol doesn't have any code. SOBoolCol has a method to create BoolValidator and methods to create backend-specific column type. BoolValidator has identical methods from_python and to_python; the method passes None, SQLExpression and bool values unchanged; int and objects that have method __nonzero__ are converted to bool; other objects trigger validation error. Bool values that are returned by call to from_python will be converted to SQL strings by BoolConverter; bool values from to_python (is is supposed they are originated from the backend via DB API driver) are passed to the application.

Objects that are returned from from_python must be registered with converters. Another approach for from_python is to return an object that has __sqlrepr__ method. Such objects convert to SQL strings themselves, converters are not used.

Style Guide

Generally you should follow the recommendations in PEP 8, the Python Style Guide. Some things to take particular note of:

  • With a few exceptions sources must be flake8-clean (and hence pep8-clean). Please consider using pre-commit hook installed by running flake8 --install-hook.

  • No tabs. Not anywhere. Always indent with 4 spaces.

  • We don't stress too much on line length. But try to break lines up by grouping with parenthesis instead of with backslashes (if you can). Do asserts like:

    assert some_condition(a, b), (
    "Some condition failed, %r isn't right!" % a)

  • But if you are having problems with line length, maybe you should just break the expression up into multiple statements.

  • Blank lines between methods, unless they are very small and closely bound to each other.

  • Never use the form condition and trueValue or falseValue. Break it out and use a variable.

  • Careful of namespace pollution. SQLObject does allow for from sqlobject import * so names should be fairly distinct, or they shouldn't be exported in sqlobject.__init__.

  • We're very picky about whitespace. There's one and only one right way to do it. Good examples:

    short = 3
longerVar = 4

if x == 4:
    do stuff

func(arg1='a', arg2='b')
func((a + b)*10)

    Bad examples:

    short    =3
longerVar=4

if x==4: do stuff

func(arg1 = 'a', arg2 = 'b')
func(a,b)
func( a, b )
[ 1, 2, 3 ]

    To us, the poor use of whitespace seems lazy. We'll think less of your code (justified or not) for this very trivial reason. We will fix all your code for you if you don't do it yourself, because we can't bear to look at sloppy whitespace.

  • Use @@ to mark something that is suboptimal, or where you have a concern that it's not right. Try to also date it and put your username there.

  • Docstrings are good. They should look like:

    class AClass(object):
    """
    doc string...
    """

    Don't use single quotes ('''). Don't bother trying make the string less vertically compact.

  • Comments go right before the thing they are commenting on.

  • Methods never, ever, ever start with capital letters. Generally only classes are capitalized. But definitely never methods.

  • mixedCase is preferred.

  • Use cls to refer to a class. Use meta to refer to a metaclass (which also happens to be a class, but calling a metaclass cls will be confusing).

  • Use isinstance instead of comparing types. E.g.:

    if isinstance(var, str): ...
# Bad:
if type(var) is StringType: ...

  • Never, ever use two leading underscores. This is annoyingly private. If name clashes are a concern, use name mangling instead (e.g., _SO_blahblah). This is essentially the same thing as double-underscore, only it's transparent where double underscore obscures.

  • Module names should be unique in the package. Subpackages shouldn't share module names with sibling or parent packages. Sadly this isn't possible for __init__, but it's otherwise easy enough.

  • Module names should be all lower case, and probably have no underscores (smushedwords).

Testing

Tests are important. Tests keep everything from falling apart. All new additions should have tests.

Testing uses py.test, an alternative to unittest. It is available at http://pytest.org/ and https://pypi.python.org/pypi/pytest. Read its getting started document for more.

To actually run the test, you have to give it a database to connect to. You do so with the option -D. You can either give a complete URI or one of several shortcuts like mysql (these shortcuts are defined in the top of tests/dbtest.py).

All the tests are modules in sqlobject/tests. Each module tests one kind of feature, more or less. If you are testing a module, call the test module tests/test_modulename.py -- only modules that start with test_ will be picked up by py.test.

The "framework" for testing is in tests/dbtest. There's a couple of important functions:

setupClass(soClass) creates the tables for the class. It tries to avoid recreating tables if not necessary.

supports(featureName) checks if the database backend supports the named feature. What backends support what is defined at the top of dbtest.

If you import * you'll also get py.test's version of raises, an inserts function that can create instances for you, and a couple miscellaneous functions.

If you submit a patch or implement a feature without a test, we'll be forced to write the test. That's no fun for us, to just be writing tests. So please, write tests; everything at least needs to be exercised, even if the tests are absolutely complete.

We now use Travis CI and Circle CI to run tests. See the statuses:

https://travis-ci.org/sqlobject/sqlobject.svg?branch=master https://circleci.com/gh/sqlobject/sqlobject.svg?style=shield

To avoid triggering unnecessary test run at CI services add text [skip ci] or [ci skip] anywhere in your commit messages for commits that don't change code (documentation updates and such).

We use coverage.py to measures code coverage by tests and upload the result for analyzis to Coveralls and Codecov:

https://coveralls.io/repos/github/sqlobject/sqlobject/badge.svg?branch=master https://codecov.io/gh/sqlobject/sqlobject/branch/master/graph/badge.svg

Documentation

Please write documentation. Documentation should live in the docs/ directory. Pudge converts documentation from Restructured Text to HTML. It presently requires kid 0.9.6, which must be obtained separately (for instance, from https://pypi.python.org/pypi/kid/0.9.6).

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.boundattributes.BoundAttribute.html0000644000175000017500000002134112754657335026715 0ustar phdphd00000000000000

BoundAttribute

This is a declarative class that passes all the values given to it to another object. So you can pass it arguments (via __init__/__call__) or give it the equivalent of keyword arguments through subclassing. Then a bound object will be added in its place.

The BoundAttribute class is accessible via the sqlobject.boundattributes module.

To hook this other object in, override make_object(added_class, name, **attrs) and maybe set_object(added_class, name, **attrs) (the default implementation of set_object just resets the attribute to whatever make_object returned).

Also see BoundFactory.

Attributes

a clone_for_subclass

True

a __unpackargs__

()

a __addtoclass__

<bound class method BoundAttribute.__addtoclass__>

a singleton

<bound class method BoundAttribute.singleton>

a __mutableattributes__

()

a __restrict_attributes__

None

a declarative_count

1

Methods

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __format__(...) ...

default object formatter

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __classinit__(cls, new_attrs) ...

f __instanceinit__(self, new_attrs) ...

f set_object(cls, added_class, attr_name, obj) ...

f make_object(cls, added_class, attr_name, *args, **attrs) ...

f __init__(self, *args, **kw) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.include.html0000644000175000017500000000410512754657316022346 0ustar phdphd00000000000000

include

The include module is accessible via the sqlobject module.

Attributes

a __package__

None

Modules

The sqlobject.include module exposes 2 submodules:

hashcol
tests

See the source for more information.

SQLObject-3.1.0/docs/html/News1.html0000644000175000017500000006132312754657232016452 0ustar phdphd00000000000000 News

News

SQLObject 0.6.1

Interface Changes

  • The long broken and unused DBMConnection has been removed.
  • Added a connection parameter to all class methods (patch 974755)
  • Connection objects have a .module attribute, which points to the DB-API module. This is useful for getting access to the exception objects.

Features

  • New UnicodeCol() that converts to and from Unicode in the database. See docs.
  • All connections are explicitly closed, not just garbage collected. Many database drivers don't close database connections properly when the connection object is garbage collected.
  • New distinct option to selects, like MyClass.select(..., distinct=True)
  • You can now do MyClass.selectBy(joinedTable=joinedTableInstance), where before you had to do MyClass.selectBy(joinedTableID=joinedTableInstance.id). (From Dave Cook)

SQLObject 0.6

Interface Changes

  • Lazy updates. Add _lazyUpdate=True to your class, and updates will only be written when you call obj.syncUpdate() or obj.sync() (sync also refetches the data from the database, which syncUpdate does not do). When enabled, instances have a property dirty, which indicates if they have pending updates. Inserts are still done immediately.
  • Separated database drivers (PostgresConnection, MySQLConnection, etc.) into separate packages. You can access the driver through URIs, like mysql://user:pass@host/dbname -- to set drivers after class creation you should use sqlobject.connectionForURI().
  • The SQLObject package has been renamed to sqlobject. This makes it similar to several other packages, and emphasizes the distinction between the sqlobject package and the SQLObject class.
  • Class instantiation now creates new rows (like .new() used to do), and the .get() method now retrieves objects that already have rows (like class instantiation used to do).
  • We're now using a Subversion repository instead of CVS. It is located at http://svn.colorstudy.com/trunk/SQLObject
  • If you pass forceDBName=True to the *Col constructors, then your column name doesn't have to be restricted to a-z, 0-9, and _.
  • *Col constructors now support cascade: cascade=None (default) means no constraint; cascade=True means that if the foreign key is deleted, the object will be deleted; cascade=False means that the delete will fail; cascade="null" means that the column will be set to NULL. The constraints are only implemented in the DBMS, not in SQLObject (i.e., they will not work in databases like MySQL and SQLite).
  • New _create(id, **kw) method that can be overridden to intercept and modify attempts to insert rows in the database.
  • You can specify _idType in your class, like _idType = str. The default type is int; i.e., IDs are coerced to integers. This is a temporary interface; a more general specifier for primary keys will be added later.
  • New classmethod createTableSQL() method for SQLObject classes, which returns the SQL that can be used to create the table. Analog to createTable().

Bugs

  • SQLite booleans fixed.
  • You can now use sqlite:/:memory: to store the database in memory.
  • Some bugs resolved when caching is turned off (SF 956847)

SQLObject 0.5.3

Bugs

  • Python 2.2 booleans fixed (SF: 903488)
  • Longs (e.g., 1L) get converted properly (SF: 939965)

SQLObject 0.5.2

We're now using Subversion instead of CVS. The repository is located at svn://colorstudy.com/trunk/SQLObject

Interface Changes

  • If you commit or rollback a transaction, you must call trans.begin() to restart the transaction. Any database access on the transaction inbetween commit/rollback and being will result in an AssertionError. (It's also acceptable to create a new transaction object instead of reusing the old one, but objects in that transaction will be invalid)

Bugs

  • Using .select() would hold on to a connection, and also release it back to the connection pool. Very un-threadsafe and all-around bad.
  • Fixed bug which did not release connections after database (query) error.
  • When setting columns that use validators, the Pythonic (vs. database) representation wasn't being stored in the column. Now we roundtrip (through toPython and fromPython) the values when they get set.
  • PostgreConnection is back to using sequences for ID generation, instead of oids. Long explanation -- oids can be unindexed in some versions of Postgres, or not even exist.
  • When turning caching off and using transactions, got an attribute error on rollback.
  • Rollback or commit didn't find objects that were expired from the cache but still in memory.
  • Rollback or commit didn't free the connection object, so as you created more transactions it stole connections and didn't put them back in the pool.

SQLObject 0.5.1

Released: 12-Nov-2003

Interface Changes

  • Select results no longer have a __len__ method (i.e., you can't do len(Person.select(Person.q.firstName=='Bob'))). There is now a .count() method instead. __len__ gets called implicitly in several circumstances, like list(), which causes potentially expensive queries to COUNT(*).

Bugs

  • Objects retrieved from a join now respect the transaction context of the original instance.
  • .select().reversed() works.

SQLObject 0.5

Released: 1-Nov-2003

Features

  • Firebird support.
  • Database-specific literal quoting (motivation: MySQL and Postgres use backslashes, Firebird and SQLite do not).
  • Generic conversion/validation can be added to columns.
  • BoolCol for portable boolean columns (BOOL on Postgres, INT on MySQL, etc.)
  • Non-integer IDs. (Automatic table creation is not supported for non-integer IDs)
  • Explicit IDs for new instances/rows (required for non-integer IDs).
  • Instances can be synced with the database (in case there have been updates to the object since it was first fetched).
  • Instances can be expired, so that they will be synced when they are next accessed.

Interface Changes

  • SQLBuilder.sqlRepr renamed to SQLBuilder.sqlrepr, signature changed to sqlrepr(value, databaseName) to quote value, where databaseName is one of "mysql", "postgres", "sqlite", "firebird".
  • sqlRepr magic method renamed to __sqlrepr__, and takes new databaseName argument.
  • When using explicit booleans, use Col.TRUE and Col.FALSE for backward compatibility with Python 2.2. This is not required for BoolCol, however (which converts all true values to TRUE and false values to FALSE)
  • SQLObject has a sqlrepr method, so you can construct queries with something like "WHERE last_name = %s" % Person.sqlrepr('Bob')

Bugs

  • Released all locks with finally:, so that bugs won't cause frozen locks.
  • Tons of transaction fixes. Transactions pretty much work.
  • A class can have multiple foreign keys pointing to the same table (e.g., spouse = ForeignKey("Person"); supervisor = ForeignKey("Person"))

SQLObject 0.4

Features

  • You can specify columns in a new, preferred manner:

    class SomeObject(SQLObject):
    someColumn = Col()

    Equivalent to:

    class SomeObject(SQLObject):
    _columns = [Col('someColumn')]

    Ditto joins.

  • Cache objects have a clear method, which empties all objects. However, weak references to objects are maintained, so the integrity of the cache can be ensured.

  • SQLObject subclasses can be further subclassed, adding or removing column definitions (as well as changing settings like connection, style, etc). Each class still refers to a single concrete table in the database -- the class hierarchy is not represented in the database.

  • Each SQLObject subclass can have an associated style, as given in the _style attribute. This object is used to map between Python and database names (e.g., the column name for a Python attribute). Some samples are available in the Style module.

  • Postgres support for _fromDatabase (reading a table definition from the database, and creating a class from that).

  • Postgres id columns more permissive, you don't have to create a specially named sequence (or implicitly create that sequence through SERIAL). lastoid is used instead.

  • MySQL uses localhost as the default host, and the empty string as the default password.

  • Added functions for use with queries: ISNULL, ISNOTNULL. == and != can be used with None, and is translated into ISNULL, ISNOTNULL.

  • Classes can be part of a specific registry. Since classes are referred to by name in several places, the names have to be unique. This can be problematic, so you can add a class variable _registry, the value of which should be a string. Classes references are assumed to be inside that registry, and class names need only be unique among classes in that registry.

  • SomeClass.select() selects all, instead of using SomeClass.select('all'). You can also use None instead of 'all'.

  • Trying to fetch non-existent objects raises SQLObjectNotFound, which is a subclass of the builtin exception LookupError. This may not be raised if _cacheValues is False and you use the ID to fetch an object (but alternateID fetches will raise the exception in either case).

  • Can order by descending order, with the reversed option to the select method, or by prefixing the column with a "-".

  • Ordering with joins works better -- you can order with multiple columns, as well as descending ordering.

Col and Join

  • Join constructors have an argument orderBy, which is the name of a Python attribute to sort results by. If not given, the appropriate class's _defaultOrder will be used. None implies no sorting (and orderBy=None will override _defaultOrder).
  • ForeignKey class (subclass of Col), for somewhat easier/clearer declaration of foreign keys.
  • Col (and subclasses) can take a sqlType argument, which is used in table definitions. E.g., Col(sqlType="BOOLEAN") can be used to create a BOOLEAN column, even though no BooleanCol exists.
  • alternateID (a specifier for columns) implies NOT NULL. Also implies UNIQUE.
  • unique (a specifier for columns) added.
  • DecimalCol and CurrencyCol added.
  • EnumCol uses constraints on Postgres (if you use createTable).

Bugs

  • DateTimeCol uses TIMESTAMP for Postgres. Note that the Python type name is used for column names, not necessarily the SQL standard name.
  • Foreign key column names are slightly more permissive. They still need to end in id, but it's case insensitive.
  • _defaultOrder should be the python attribute's name, not the database name.
  • SomeClass.q.colName uses proper Python attributes for colName, and proper database names when executed in the database.
  • SQLite select results back to being proper iterator.
  • SomeClass.q.colName now does proper translation to database names, using dbName, etc., instead of being entirely algorithm-driven.
  • Raise TypeError if you pass an unknown argument to the new method.
  • You can override the _get_* or _set_* version of a property without overriding the other.
  • Python 2.3 compatible.
  • Trying to use Col('id') or id = Col() will raise an exception, instead of just acting funky.
  • ForeignKey columns return None if the associated column is NULL in the database (used to just act weird).
  • Instantiating an object with an id of None will give an error, instead of just acting weird.

Internal

  • Col class separated into Col and SOCol (and same for all other *Col classes). Col defines a column, SOCol is that definition bound to a particular SQLObject class.
  • Instance variable _SO_columns holds the SOCol instances.

SQLObject 0.3

Features

  • Table creation (SQL schema generation) via new class method createTable. And of course a dropTable method to go with.
  • Add and remove columns at runtime, optionally modifying the schema in the database (via ALTER). (Does not work in SQLite)
  • New column classes (see Col module), indicates type
  • Classes can be created by parsing an already existant table (MySQL only).
  • Objects are not cached indefinitely. Cached objects are expired into a weak dictionary (it allows objects to be garbage collected if nowhere else in the program is using the object, but until it is collected it's still available to the cache). Some cache control, pass nocache=True to your connection object to eliminate as much caching as possible. See Cache module for a bit more.
  • New DBMConnection, implements a database-like backend without any database to speak of, including queries (so long as you use SQLBuilder and don't generate your where clauses manually). Actual SQL generation is done entirely by the database connection, allowing portability across very different backends.
  • Postgres table IDs should be created with type SERIAL (which implicitly creates a sequence).
  • New _defaultOrder class variable gives a default for the orderBy parameter to select queries.

Bugs

  • LIMIT/OFFSET (select result slicing) works in Postgres and SQLite.
  • tableExists method from DBConnection works in same.
  • mxDateTime not required (never should have been, always just an option).

SQLObject 0.2.1

Bugs

  • Fixed caching of new objects

Features

  • SQLite support
  • Select statements are lazily generated, retrieve full rows for speed, and are slicable (select docs).
  • alternateID option for Col objects -- select individual objects via UNIQUE columns, e.g., a username (Col docs).
Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.dbconnection.ConnWrapper.html0000644000175000017500000000752712754657340025455 0ustar phdphd00000000000000

ConnWrapper

This represents a SQLObject class that is bound to a specific connection (instances have a connection instance variable, but classes are global, so this is binds the connection variable lazily when a class method is accessed)

The ConnWrapper class is accessible via the sqlobject.dbconnection module.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, soClass, connection) ...

f __call__(self, *args, **kw) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.KeyCol.html0000644000175000017500000000746312754657347022523 0ustar phdphd00000000000000

KeyCol

The KeyCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.AliasField.html0000644000175000017500000004131312754657327024711 0ustar phdphd00000000000000

AliasField

The AliasField class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f execute(self, executor) ...

f __init__(self, tableName, fieldName, alias, aliasTable) ...

f __sqlrepr__(self, db) ...

f tablesUsedImmediate(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Subquery.html0000644000175000017500000004032112754657330024523 0ustar phdphd00000000000000

Subquery

The Subquery class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, op, subquery) ...

f __sqlrepr__(self, db) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.rdbhost.rdbhostconnection.html0000644000175000017500000000514212754657323026114 0ustar phdphd00000000000000

rdbhostconnection

This module written by David Keeney, 2009, 2010

The rdbhostconnection module is accessible via the sqlobject.rdbhost module.

Released under the LGPL for use with the SQLObject ORM library.

Attributes

a __package__

'sqlobject.rdbhost'

Classes

C RdbhostConnection(...) ...

This class contains 5 members.

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOUuidCol.html0000644000175000017500000002451612754657351023134 0ustar phdphd00000000000000

SOUuidCol

The SOUuidCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(self, name, soClass, creationOrder, dbName=None, default=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, notNone=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, unique=<class sqlobject.sqlbuilder.NoDefault at 0xb63fff2c>, sqlType=None, columnDef=None, validator=None, validator2=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=False, title=None, tags=[], origName=None, dbEncoding=None, extra_vars=None) ...

f autoConstraints(self) ...

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOJSONCol.html0000644000175000017500000002336312754657352022777 0ustar phdphd00000000000000

SOJSONCol

The SOJSONCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.IntCol.html0000644000175000017500000000746312754657350022517 0ustar phdphd00000000000000

IntCol

The IntCol class is accessible via the sqlobject.col module.

Attributes

a name

<property object at 0xb64f9d74>

Methods

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(self, name=None, **kw) ...

f withClass(self, soClass) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.boundattributes-index.html0000644000175000017500000001752412754657335025260 0ustar phdphd00000000000000 Index of sqlobject.boundattributes module

Index of the boundattributes module

SQLObject-3.1.0/docs/html/News2.html0000644000175000017500000006726612754657232016467 0ustar phdphd00000000000000 News

News

SQLObject 0.8.7

Released 10 Jan 2008.

SQLObject 0.8.6

Released 30 Oct 2007.

  • Removed SelectResults.__nonzero__, which was a design mistake. Raising an exception in __nonzero__() is inconsistent with other iterators (bool(iter([])) => True).
  • A number of changes ported from SQLObject 0.7.9.

SQLObject 0.8.5

Released 25 July 2007.

Bug Fixes

  • Suppress the second RowUpdateSignal in .set() called from ._SO_setValue().

SQLObject 0.8.4

Released 10 May 2007.

Bug Fixes

  • A number of bugfixes forward-ported from 0.7.7.

SQLObject 0.8.3

Released 3 May 2007.

Bug Fixes

  • A number of bugfixes forward-ported from 0.7.6.

SQLObject 0.8.2

Released 11 Apr 2007.

Bug Fixes

  • Fixed ConnectionHub.doInTransaction() - if the original connection was processConnection - reset processConnection, not threadConnection.

SQLObject 0.8.1

Released 19 Mar 2007.

Bug Fixes

  • ID columns are reverted back from INT UNSIGNED to INT for MySQL to be in accord with FOREIGN KEYs.
  • Fixed return value from Firebird/MaxdbConnection.createTable().
  • Fixed and simplified DatabaseIndex.get().
  • Fixed ConnectionHub.doInTransaction() - close low-level connection on commit() to prevent connections leaking.

SQLObject 0.8.0

Released 12 Feb 2007.

Features & Interface

  • It is now possible to create tables that reference each other. Constraints (in the DBMSes that support constraints) are added after the tables have been created.

  • Added createSQL as an option for sqlmeta. Here you can add related SQL you want executed by sqlobject-admin create after table creation. createSQL expects a string, list, or dictionary. If using a dictionary the key should be a dbName value (ex. 'postgres') and the value should be a string or list. Examples in sqlobject/tests/test_sqlobject_admin.py or at <http://sqlobject.org/sqlobject-admin.html#the-create-command>

  • Added method sqlhub.doInTransaction(callable, *args, **kwargs), to be used like:

    sqlhub.doInTransaction(process_request, os.environ)

    This will run process_request(os.environ). The return value will be preserved.

  • Added method .getOne([default]) to SelectResults (these are the objects returned by .select() and .selectBy()). This returns a single object, when the query is expected to return only one object. The single argument is the value to return when zero results are found (more than one result is always an error). If no default is given, it is an error if no such object exists.

  • Added a WSGI middleware (in sqlobject.wsgi_middleware) for configuring the database for the request. Also handles transactions. Available as egg:SQLObject in Paste Deploy configuration files.

  • New joins! ManyToMany and OneToMany; not fully documented yet, but still more sensible and smarter.

  • SELECT FOR UPDATE

  • New module dberrors.py - a hierarchy of exceptions. Translation of DB API module's exceptions to the new hierarchy is performed for SQLite and MySQL.

  • SQLiteConnection got a new keyword "factory" - a name or a reference to a factory function that returns a connection class; useful for implementing functions or aggregates. See test_select.py and test_sqlite_factory.py for examples.

  • SQLObject now disallows columns with names that collide with existing variables and methods, such as "_init", "expire", "set" and so on.

Small Features

  • Configurable client character set (encoding) for MySQL.
  • Added a close option to .commit(), so you can close the transaction as you commit it.
  • DecimalValidator.
  • Added .expireAll() methods to sqlmeta and connection objects, to expire all instances in those cases.
  • String IDs.
  • FOREIGN KEY for MySQL.
  • Support for sqlite3 (a builtin module in Python 2.5).
  • SelectResults cannot be queried for truth value; in any case it was meaningless - the result was always True; now __nonzero__() raises NotImplementedError in case one tries bool(MyTable.select()) or "if MyTable.select():..."
  • With empty parameters AND() and OR() returns None.
  • Allows to use set/frozenset sets/Set/ImmutableSet sets as sequences passed to the IN operator.
  • ID columns are now INT UNSIGNED for MySQL.

Bug Fixes

  • Fixed problem with sqlite and threads; connections are no longer shared between threads for sqlite (except for :memory:).
  • The reference loop between SQLObject and SQLObjectState eliminated using weak references.
  • Another round of bugfixes for MySQL errors 2006 and 2013 (SERVER_GONE, SERVER_LOST).
  • Fixed a bug in MSSQLConnection caused by column names being unicode.
  • Fixed a bug in FirebirdConnection caused by column names having trailing spaces.
  • Order by several columns with inheritance.
  • Fixed aggregators and accumulators with inheritance.

SQLObject 0.7.10

Released 10 Jan 2008.

  • With PySQLite2 do not use encode()/decode() from PySQLite1 - always use base64 for BLOBs.
  • MySQLConnection doesn't convert query strings to unicode (but allows to pass unicode query strings if the user build ones). DB URI parameter sqlobject_encoding is no longer used.

SQLObject 0.7.9

Released 30 Oct 2007.

Bug Fixes

  • Remove 'limit' from SelectResults after setting start/end so .clone() never sees limit again.
  • Fixed a bug in sqlbuilder._LikeQuoted() - call sqlrepr() on the expression to escape single quotes if the expression is a string.
  • Fixed StringCol and UnicodeCol: use sqlType with MSSQL.
  • Fixed startswith/endswith/contains for UnicodeCol.

Other Changes

  • Changed the default value for 'varchar' in BLOBColumns from 'auto' to False (so that the default type for the columns in MySQL is BLOB, not TEXT).
  • Changed the implementation type in BoolCol under MySQL from TINYINT to BOOL (which is a synonym for TINYINT(1)).

SQLObject 0.7.8

Released 25 July 2007.

Bug Fixes

  • Replaced calls to style.dbColumnToPythonAttr() in joins.py by name/dbName lookup in case the user named columns differently using dbName.
  • Minor correction in the tests: we fully support EnumCol in Postgres.
  • MySQLConnection now recognizes Enum, Double and Time columns when drawing the database scheme from DB.
  • Minor fix in FirebirdConnection.fromDatabase.
  • Fixed a bug with default field values for columns for Firebird connection.
  • Fixed a bug in col.createSQL().
  • Fixed a bug in converting date/time for years < 1000 (time.strptime() requires exactly 4 digits for %Y, hence a year < 1000 must be 0-padded).

Other Changes

  • Changed string quoting style for PostgreSQL and MySQL from \' to ''.

SQLObject 0.7.7

Released 10 May 2007.

Bug Fixes

  • Fixed a bug in SQLRelatedJoin that ignored per-instance connection.
  • Fixed a bug in MySQL connection in case there is no charset in the DB URI.

SQLObject 0.7.6

Released 3 May 2007.

Bug Fixes

  • Fixed a longstanding bug with .select() ignoring 'limit' parameter.
  • Fixed a bug with absent comma in JOINs.
  • Fixed sqlbuilder - .startswith(), .endswith() and .contains() assumed their parameter must be a string; now you can pass an SQLExpression: Table.q.name.contains(func.upper('a')), for example.
  • Fixed a longstanding bug in sqlbuilder.Select() with groupBy being a sequence.
  • Fixed a bug with Aliases in JOINs.
  • Yet another patch to properly initialize MySQL connection encoding.
  • Fixed a minor comparison problem in test_decimal.py.
  • More documentation about orderBy.

SQLObject 0.7.5

Released 11 Apr 2007.

Bug Fixes

  • Fixed test_deep_inheritance.py - setup classes in the correct order (required for Postgres 8.0+ which is strict about referential integrity).
  • Fixed a bug in DateValidator caused by datetime being a subclass of date.

SQLObject 0.7.4

Released 19 Mar 2007.

Small Features

  • For MySQLdb 1.2.2+ call ping(True) on the connection to allow autoreconnect after a timeout.

Bug Fixes

  • Another round of changes to create/drop the tables in the right order in the command-line client sqlobject-admin.
  • Fixed a bug in UnicodeField - allow comparison with None.

SQLObject 0.7.3

Released 30 Jan 2007.

Bug Fixes

  • Allow multiple MSSQL connections.
  • Psycopg1 requires port to be a string; psycopg2 requires port to be an int.
  • Fixed a bug in MSSQLConnection caused by column names being unicode.
  • Fixed a bug in FirebirdConnection caused by column names having trailing spaces.
  • Fixed a missed import in firebirdconnection.py.
  • Remove a leading slash in FirebirdConnection.
  • Fixed a bug in deep Inheritance tree.

SQLObject 0.7.2

Released 20 Nov 2006.

Features & Interface

  • sqlbuilder.Select now supports JOINs exactly like SQLObject.select.
  • destroySelf() removes the object from related joins.

Bug Fixes

  • Fixed a number of unicode-related problems with newer MySQLdb.
  • If the DB API driver returns timedelta instead of time (MySQLdb does this) it is converted to time; but if the timedelta has days an exception is raised.
  • Fixed a number of bugs in InheritableSQLObject related to foreign keys.
  • Fixed a bug in InheritableSQLObject related to the order of tableRegistry dictionary.
  • A bug fix that allows to use SQLObject with DateTime from Zope.

Documentation Added

  • Added "How can I define my own intermediate table in my Many-to-Many relationship?" to FAQ.

SQLObject 0.7.1

Released 25 Sep 2006.

Features & Interface

  • Added support for MSSQL.
  • Added TimeCol.
  • RelatedJoin and SQLRelatedJoin objects have a createRelatedTable keyword argument (default True). If False, then the related table won't be automatically created; instead you must manually create it (e.g., with explicit SQLObject classes for the joins).
  • Implemented RLIKE (regular expression LIKE).
  • Moved _idSequence to sqlmeta.idSequence.

Small Features

  • Select over RelatedJoin.
  • SQLite foreign keys.
  • Postgres DB URIs with a non-default path to unix socket.
  • Allow the use of foreign keys in selects.
  • Implemented addColumn() for SQLite.
  • With PySQLite2 use encode()/decode() from PySQLite1 for BLOBCol if available; else use base64.

Bug Fixes

  • Fixed a longstanding problem with UnicodeCol - at last you can use unicode strings in .select() and .selectBy() queries. There are some limitations, though; see the description of the UnicodeCol.
  • Cull patch (clear cache).
  • .destroySelf() inside a transaction.
  • Synchronize main connection cache during transaction commit.
  • Ordering joins with NULLs.
  • Fixed bugs with plain/non-plain setters.
  • Lots of other bug fixes.

SQLObject 0.7.0

Features & Interface

  • Date/time validators, converters, tests.
  • Both mxDateTime and datetime supported for DateTimeCol.
  • Added BLOBCol, for binary data.
  • Added PickleCol, to transparently pickle and unpickle data from column.
  • New documented reflection interface, using the new .sqlmeta class/instance. Most special attributes that started with _ were moved into sqlmeta (with leading underscore removed).
  • New aggregate functions for select results, like cls.select().max(columnName): .max(), .min(), .avg().
  • ConnectionHub aka sqlhub (@@: Needs documentation)
  • Command-line client sqlobject-admin.
  • StringCol has char_binary attribute, for explicit case handling in MySQL.
  • Various joins now supported (LEFT, RIGHT, STRAIGHT, INNER, OUTER, CROSS): see documentation. Aliases for joining a table with itself.
  • Subqueries/subselects (see docs).
  • Select results support .filter(extra_query)
  • SQLMultipleJoin and SQLRelatedJoin, like MultipleJoin and RelatedJoin, except return select results (@@: Document).
  • SingleJoin.
  • Columns retain their order from the class definition to table creation.
  • SQLObject now depends on the FormEncode library, and internal conversion/validation is done through FormEncode (was previously using old fork of FormEncode).
  • Column instances can have attributes set on them (generally for annotating columns with extra data).

Other Changes

  • When iterating over select results, a list is now immediately created with the full list of instances being selected. Before instances were created on demand, as select results were pulled out row-by-row. The previous lazy behavior is available with the method lazyIter, used like for obj in MyClass.select().lazyIter(): ....
  • Test framework now uses py.test.
  • SQLObject now uses a simpler metaclass (sqlobject.declarative.DeclarativeMeta).
  • autoCommit and queryIns ?? (@@: expand)
  • Deprecation (@@: document)
  • Use setuptools for packaging and installation.

Small Features

  • IntValidator for testing IntCol inputs.
  • Base style (sqlobject.styles.Style) is now a usable no-op style.
  • SQLite in-memory databases allowed with sqlite:/:memory:
  • Keyword parameters allowed to connectionForURI (like debug=True).
  • More parameters passed to MySQL connections (unix_socket, named_pipe, init_command, read_default_file, read_default_group, connect_time, compress, named_pipe, use_unicode, client_flag, local_infile).
  • DateTimeCol.now is a function for producing the current date, using whatever date/time module you are using (good for use as a default).
  • Inherited classes fetched more efficiently (fewer queries).
  • Decimal converter to create decimal objects.
  • Repository rearranged (now in http://svn.colorstudy.com/SQLObject/trunk).

Bug Fixes

  • Tables with no columns can work. Why would you have a table without a column? We do not know, we try only to serve.
  • Sybase _fromDatabase fixed.
  • Various fixes to support most recent MySQLdb adapter, and pysqlite adapters.
  • URI parsing improved, including Windows paths (for use with SQLite).
  • selectBy(column=None) creates IS NULL query.
  • selectBy(foreignKey=value) now supported (not just selecting by foreign key ID).
  • cascade='null' wasn't working properly (was cascading all deletes, not nullifying!).
  • Lots of other bug fixes.

Older news

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/module-sqlobject.__version__-index.html0000644000175000017500000000720112754657341024307 0ustar phdphd00000000000000 Index of sqlobject.__version__ module

Index of the __version__ module

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.Warning.html0000644000175000017500000001321212754657322023765 0ustar phdphd00000000000000

Warning

The Warning class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.SQLObjectField.html0000644000175000017500000004156712754657331025454 0ustar phdphd00000000000000

SQLObjectField

The SQLObjectField class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f components(self) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f __sqlrepr__(self, db) ...

f tablesUsedImmediate(self) ...

f execute(self, executor) ...

f __init__(self, tableName, fieldName, original, soClass, column) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.IntegrityError.html0000644000175000017500000001333612754657322025357 0ustar phdphd00000000000000

IntegrityError

The IntegrityError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.events.RowUpdateSignal.html0000644000175000017500000000722312754657342025121 0ustar phdphd00000000000000

RowUpdateSignal

Called when an instance is updated through a call to .set() (or a column attribute assignment). The arguments are (instance, kwargs). kwargs can be modified. This is run before the instance is updated; if you want to look at the current values, simply look at instance.

The RowUpdateSignal class is accessible via the sqlobject.events module.

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.sqlbuilder.Alias.html0000644000175000017500000004012112754657333023736 0ustar phdphd00000000000000

Alias

The Alias class is accessible via the sqlobject.sqlbuilder module.

Methods

f __add__(self, other) ...

f __radd__(self, other) ...

f __sub__(self, other) ...

f __rsub__(self, other) ...

f __mul__(self, other) ...

f __rmul__(self, other) ...

f __div__(self, other) ...

f __rdiv__(self, other) ...

f __pos__(self) ...

f __neg__(self) ...

f __pow__(self, other) ...

f __rpow__(self, other) ...

f __abs__(self) ...

f __mod__(self, other) ...

f __rmod__(self, other) ...

f __lt__(self, other) ...

f __le__(self, other) ...

f __gt__(self, other) ...

f __ge__(self, other) ...

f __eq__(self, other) ...

f __ne__(self, other) ...

f __and__(self, other) ...

f __rand__(self, other) ...

f __or__(self, other) ...

f __ror__(self, other) ...

f __invert__(self) ...

f __call__(self, *args) ...

f __cmp__(self, other) ...

f __rcmp__(self, other) ...

f startswith(self, s) ...

f endswith(self, s) ...

f contains(self, s) ...

f tablesUsed(self, db) ...

f tablesUsedSet(self, db) ...

f tablesUsedImmediate(self) ...

f __init__(self, table, alias=None) ...

f __sqlrepr__(self, db) ...

f components(self) ...

See the source for more information.

SQLObject-3.1.0/docs/html/class-sqlobject.col.SOStringCol.html0000644000175000017500000002344612754657351023475 0ustar phdphd00000000000000

SOStringCol

The SOStringCol class is accessible via the sqlobject.col module.

Attributes

a validator

<property object at 0xb64f793c>

a default

<property object at 0xb64f72d4>

a joinName

<property object at 0xb64f7f2c>

Methods

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f createSQL(self) ...

f mysqlCreateSQL(self, connection=None) ...

f postgresCreateSQL(self) ...

f sqliteCreateSQL(self) ...

f sybaseCreateSQL(self) ...

f mssqlCreateSQL(self, connection=None) ...

f firebirdCreateSQL(self) ...

f maxdbCreateSQL(self) ...

f __get__(self, obj, type=None) ...

f __set__(self, obj, value) ...

f __delete__(self, obj) ...

f getDbEncoding(self, state, default='utf-8') ...

f __init__(self, **kw) ...

f autoConstraints(self) ...

f createValidators(self, dataType=None) ...

See the source for more information.

SQLObject-3.1.0/docs/html/module-sqlobject.sqlite.sqliteconnection-index.html0000644000175000017500000002461612754657336026724 0ustar phdphd00000000000000 Index of sqlobject.sqlite.sqliteconnection module

Index of the sqliteconnection module

SQLObject-3.1.0/docs/html/community.html0000644000175000017500000000765712754657232017513 0ustar phdphd00000000000000 SQLObject Community

SQLObject Community

SQLObject questions and discussion happens on the sqlobject-discuss mailing list. Gmane also has the list in gmane.comp.python.sqlobject accessible by HTTP, HTTP (blog format) and News.

Bugs should be submitted to the bug tracker at SourceForge or GitHub, and patches to the patch tracker (or send pull requests at GitHub).

Development takes place in the git repositories. There are development docs. If you are interested in contributing you should read the Developer Guide. There also exists ##sqlobject on the Freenode IRC Network for development discussions.

The Author List tries to list all the major contributors.

One can also contribute to community-editable recipe/documentation site.

Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads
SQLObject-3.1.0/docs/html/class-sqlobject.dberrors.OperationalError.html0000644000175000017500000001336612754657322025661 0ustar phdphd00000000000000

OperationalError

The OperationalError class is accessible via the sqlobject.dberrors module.

Attributes

a args

<attribute 'args' of 'exceptions.BaseException' objects>

a message

<attribute 'message' of 'exceptions.BaseException' objects>

Methods

f __getitem__(...) ...

x.__getitem__(y) <==> x[y]

f __getslice__(...) ...

x.__getslice__(i, j) <==> x[i:j]

Use of negative indices is not supported.

f __setstate__(...) ...

f __format__(...) ...

default object formatter

f __subclasshook__(...) ...

Abstract classes can override this to customize issubclass().

This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

f __unicode__(...) ...

f __sizeof__(...) ...

__sizeof__() -> int size of object in memory, in bytes

f __init__(...) ...

x.__init__(...) initializes x; see help(type(x)) for signature

See the source for more information.

SQLObject-3.1.0/docs/sqlobject-admin.rst0000644000175000017500000001642712752476767017450 0ustar phdphd00000000000000++++++++++++++++++++++++ The sqlobject-admin Tool ++++++++++++++++++++++++ :author: Ian Bicking :revision: $Rev$ :date: $LastChangedDate$ .. contents:: .. warning:: This document isn't entirely accurate; some of what it describes are the intended features of the tool, not the actual features. Particularly inaccurate is how modules and classes are found. Introduction ------------ The ``sqlobject-admin`` tool included with SQLObject allows you to manage your database as defined with SQLObject classes. Some of the features include creating tables, checking the status of the database, recording a version of a schema, and updating the database to match the version of the schema in your code. To see a list of commands run ``sqlobject-admin help``. Each sub-command has ``-h`` option which explains the details of that command. Common Options ============== Many of the commands share some common options, mostly for finding the database and classes. ``-c CONNECTION`` or ``--connection=CONNECTION``: This takes an argument, the connection string for the database. This overrides any connection the classes have (if they are hardwired to a connection). ``-f FILENAME`` or ``--config-file=FILENAME``: This is a configuration file from which to get the connection. This configuration file should be a Python-syntax file that defines a global variable ``database``, which is the connection string for the database. ``-m MODULE`` or ``--module=MODULE``: A module to look in for classes. ``MODULE`` is something like ``myapp.amodule``. Remember to set your ``$PYTHONPATH`` if the module can't be imported. You can provide this argument multiple times. ``-p PACKAGE`` or ``--package=PACKAGE``: A package to look in. This looks in all the modules in this class and subclasses for SQLObject classes. ``--class=CLASSMATCH``: This *restricts* the classes found to the matching classes. You may use wildcards. You can provide multiple ``--class`` arguments, and if any pattern matches the class will be included. ``--egg=EGG_SPEC``: This is an `Egg `_ description that should be loaded. So if you give ``--egg=ProjectName`` it'll load that egg, and look in ``ProjectName.egg-info/sqlobject.txt`` for some settings (like ``db_module`` and ``history_dir``). When finding SQLObject classes, we look in the modules for classes that belong to the module -- so if you import a class from another module it won't be "matched". You have to indicate its original module. If classes have to be handled in a specific order, create a ``soClasses`` global variable that holds a list of the classes. This overrides the module restrictions. This is important in databases with referential integrity, where dependent tables can't be created before the tables they depend on. Simple Commands =============== The ``create`` Command ---------------------- This finds the tables and creates them. Any tables that exist are simply skipped. It also collects data from sqlmeta.createSQL (added in svn trunk) and runs the queries after table creation. createSQL can be a string with a single SQL command, a list of SQL commands, or a dictionary with keys that are dbNames and values that are either single SQL command string or a list of SQL commands. An example follows:: class MyTable(SQLObject): class sqlmeta: createSQL = {'postgres': [ "ALTER TABLE my_table ADD CHECK(my_field != '');", ]} myField = StringCol() The ``sql`` Command ------------------- This shows the SQL to create all the tables. The ``drop`` Command -------------------- Drops tables! Missing tables are skipped. The ``execute`` Command ----------------------- This executes an arbitrary SQL expression. This is mostly useful if you want to run a query against a database described by a SQLObject connection string. Use ``--stdin`` if you want to pipe commands in; otherwise you give the commands as arguments. The ``list`` Command -------------------- Lists out all the classes found. This can help you figure out what classes you are dealing with, and if there's any missing that you expected. The ``status`` Command ---------------------- This shows if tables are present in the database. If possible (it depends on the database) it will also show if the tables are missing any columns, or have any extra columns, when compared to the table the SQLObject class describes. It doesn't check column types, indexes, or constraints. This feature may be added in the future. Versioning & Upgrading ====================== There's two commands related to storing the schema and upgrading the database: ``record`` and ``upgrade``. The idea is that you record each iteration of your schema, and this gets a version number. Something like ``2003-05-04a``. If you are using source control you'll check all versions into your repository; you don't overwrite one with the next. In addition to the on-disk record of the different schemas you have gone through, the database itself contains a record of what version it is at. By having all the versions available at once, we can upgrade from any version. But more on that `later `_ Basic Usage ----------- Here's a quick summary of how you use these commands: 1. In project where you've never used ``sqlobject-admin`` before, you run ``sqlobject-admin record --output-dir=sqlobject-history``. If your active database is up-to-date with the code, then the tool will add a ``sqlobject_db_version`` table to the database with the current version. 2. Now, make some updates to your code. Don't update the database! (You could, but for now it's more fun if you don't.) 3. Run ``sqlobject-admin record --edit``. A new version will be created, and an editor will be opened up. The ``record`` Command ---------------------- Record will take the SQL ``CREATE`` statements for your tables, and output them in new version. It creates the version by using the ISO-formatted date (YYYY-MM-DD) and a suffix to make it unique. It puts each table in its own file. This normally doesn't touch the database at all -- it only records the schema as defined in your code, regardless of the database. In fact, I recommend calling ``record`` *before* you update your database. The ``upgrade`` Command ----------------------- Future ====== * Get ``record`` to do ``svn cp`` when creating a new version, then write over those files; this way the version control system will have nice diffs. * An option to ``record`` the SQL for multiple database backends at once (now only the active backend is recorded). * An option to upgrade databases with Python scripts instead of SQL commands. Or a little of both. * Review all the verbosity, maybe add logging, review simulation. * Generate simple ``ALTER`` statements for upgrade scripts, to give people something to work with. Maybe. * A command to trim versions, by merging upgrade scripts. .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/download.rst0000644000175000017500000000353512752476767016177 0ustar phdphd00000000000000Download SQLObject ++++++++++++++++++ The latest releases are always available on the `Python Package Index `_, and is installable with `pip `_ or `easy_install `_. You can install the latest release with:: pip install -U SQLObject or:: easy_install -U SQLObject You can install the latest version of SQLObject with:: easy_install SQLObject==dev You can install the latest bug fixing branch with:: easy_install SQLObject==bugfix If you want to require a specific revision (because, for instance, you need a bugfix that hasn't appeared in a release), you can put this in your `setuptools `_ using ``setup.py`` file:: setup(... install_requires=["SQLObject==bugfix,>=0.7.1dev-r1485"], ) This says that you *need* revision 1485 or higher. But it also says that you can aquire the "bugfix" version to try to get that. In fact, when you install ``SQLObject==bugfix`` you will be installing a specific version, and "bugfix" is just a kind of label for a way of acquiring the version (it points to a branch in the repository). Repositories ------------ The SQLObject `git `_ repositories are located at https://sourceforge.net/p/sqlobject/_list/git and https://github.com/sqlobject Before switching to git development was performed at the `Subversion `_ repository that is still located at http://svn.colorstudy.com/SQLObject .. image:: https://sourceforge.net/sflogo.php?group_id=74338&type=10 :target: https://sourceforge.net/projects/sqlobject :class: noborder :align: center :height: 15 :width: 80 :alt: Get SQLObject at SourceForge.net. Fast, secure and Free Open Source software downloads SQLObject-3.1.0/docs/default.css0000644000175000017500000001176511174060057015752 0ustar phdphd00000000000000/* :Author: David Goodger :Contact: goodger@users.sourceforge.net :date: $Date: 2003/06/28 22:18:49 $ :version: $Revision: 1.2 $ :copyright: This stylesheet has been placed in the public domain. Default cascading style sheet for the HTML output of Docutils. */ body { background-color: #eeeeee; font-family: Arial, sans-serif; } em { font-family: Times New Roman, Times, serif; } li { list-style-type: circle; } a.target { color: blue } a.toc-backref { text-decoration: none ; color: black } a:hover { background-color: #cccccc; } cite { font-style: normal; font-family: monospace; font-weight: bold; } dd { margin-bottom: 0.5em } div.abstract { margin: 2em 5em } div.abstract p.topic-title { font-weight: bold ; text-align: center } div.attention, div.caution, div.danger, div.error, div.hint, div.important, div.note, div.tip, div.warning { // margin: 2em ; background-color: #cccccc; align: center; width: 40%; border: medium outset ; padding: 3px; float: right; } div.attention p.admonition-title, div.caution p.admonition-title, div.danger p.admonition-title, div.error p.admonition-title, div.warning p.admonition-title { color: red ; font-weight: bold ; font-family: sans-serif; text-align: center; display: block; background-color: #999999; margin: 0; } div.hint p.admonition-title, div.important p.admonition-title, div.note p.admonition-title, div.tip p.admonition-title { font-weight: bold ; font-family: sans-serif; text-align: center; display: block; background-color: #999999; margin: 0; } div.dedication { margin: 2em 5em ; text-align: center ; font-style: italic } div.dedication p.topic-title { font-weight: bold ; font-style: normal } div.figure { margin-left: 2em } div.footer, div.header { font-size: smaller } div.system-messages { margin: 5em } div.system-messages h1 { color: red } div.system-message { border: medium outset ; padding: 1em } div.system-message p.system-message-title { color: red ; font-weight: bold } div.topic { margin: 2em } h1, h2, h3, h4, h5, h6 { font-family: Helvetica, Arial, sans-serif; border: thin solid black; -moz-border-radius: 8px; padding: 4px; } h1 { background-color: #444499; border: medium solid black; color: #ffffff; } h2 { background-color: #666666; color: #ffffff; border: medium solid black; } h1 a:link, h2 a:link { color: #ffffff; } h3, h4, h5, h6 { background-color: #cccccc; color: #000000; } h3 a:link, h4 a:link, h5 a:link, h6 a:link { color: #000000; } h1.title { text-align: center; background-color: #444499; color: #eeeeee; border: thick solid black; -moz-border-radius: 20px; } h2.subtitle { text-align: center } hr { width: 75% } ol.simple, ul.simple { margin-bottom: 1em } ol.arabic { list-style: decimal } ol.loweralpha { list-style: lower-alpha } ol.upperalpha { list-style: upper-alpha } ol.lowerroman { list-style: lower-roman } ol.upperroman { list-style: upper-roman } p.caption { font-style: italic } p.credits { font-style: italic ; font-size: smaller } p.first { margin-top: 0 } p.label { white-space: nowrap } p.topic-title { font-weight: bold } pre.address { margin-bottom: 0 ; margin-top: 0 ; font-family: serif ; font-size: 100% } pre.line-block { font-family: serif ; font-size: 100% } pre.literal-block, pre.doctest-block { margin-left: 2em ; margin-right: 2em ; background-color: #ffffff; border: thin black solid; padding: 5px; } span.classifier { font-family: sans-serif ; font-style: oblique } span.classifier-delimiter { font-family: sans-serif ; font-weight: bold } span.interpreted { font-family: sans-serif } span.option-argument { font-style: italic } span.pre { white-space: pre } span.problematic { color: red } table { margin-top: 0.5em ; margin-bottom: 0.5em } table.citation { border-left: solid thin gray ; padding-left: 0.5ex } table.docinfo { margin: 2em 4em } table.footnote { border-left: solid thin black ; padding-left: 0.5ex } td, th { padding-left: 0.5em ; padding-right: 0.5em ; vertical-align: top } td > p:first-child, th > p:first-child { margin-top: 0em } th.docinfo-name, th.field-name { font-weight: bold ; text-align: left ; white-space: nowrap } h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt { font-size: 100% } tt { //background-color: #eeeeee; color: #000066 } ul.auto-toc { list-style-type: none } // Highlighting: .function {color: #000077; font-weight: bold} .keyword {color: #004444;} .comment {color: #770000; font-style: italic} .normal {color: #000000;} .string {color: #006600;} .symbol {color: #000000;} .htmltag {color: #000077;} .htmlsymbol {color: #000000;} .htmlnormal {color: #000000;} .htmlcomment {color: #770000; font-style: italic} .htmlstring {color: #006600;} .htmlattr {color: #000000;} .stmlfunction {color: #000077; font-weight: bold} .stmlattr {color: #000000;} .stmlstring {color: #006600;} .stmlexpr {color: #004444;} img.noborder {border-style: none;} SQLObject-3.1.0/debian/0000755000175000017500000000000012754657361014113 5ustar phdphd00000000000000SQLObject-3.1.0/debian/control0000644000175000017500000000124010066344323015474 0ustar phdphd00000000000000Source: sqlobject Section: python Priority: optional Maintainer: Philippe Normand (phil) Build-Depends: debhelper (>= 4.0.0), python-dev (>= 2.3) Standards-Version: 3.6.1 Package: python-sqlobject #Section: python Architecture: any Depends: ${python:Depends} Recommends: python-mysqldb (>= 0.9.2-0.4), python-sqlite (>= 0.4.3-2), python-psycopg (>= 1.1.13-1), python-kinterbasdb (>= 3.0.1-3.1), python-maxdb (>= 7.5.00.12-1) Description: An object-relational mapper for Python It allows you to translate RDBMS table rows into Python objects, and manipulate those objects to transparently manipulate the database. . Homepage: http://sqlobject.org SQLObject-3.1.0/debian/docs0000644000175000017500000000002112752476767014766 0ustar phdphd00000000000000README.rst docs/ SQLObject-3.1.0/debian/changelog0000644000175000017500000000112610066344323015746 0ustar phdphd00000000000000sqlobject (0.6-1) unstable; urgency=low * Debian package will be part of the Colorstudy SVN repository * Added Build-dependencies : python-{mysqldb,sqlite,psycopg,kinterbasdb,maxdb} * Fixed copyright to suit new SQLOBject license -- Philippe Normand (phil) Tue, 8 Jun 2004 20:39:16 +0200 sqlobject (0.5.2-1) unstable; urgency=low * Update to 0.5.2. -- Keisuke URAGO Sat, 5 Jun 2004 02:32:43 +0900 sqlobject (0.3-1) unstable; urgency=low * New upstream version. -- Keisuke URAGO Fri, 09 May 2003 17:06:23 +0900 SQLObject-3.1.0/debian/copyright0000644000175000017500000000054710066344323016035 0ustar phdphd00000000000000This package was debianized by Keisuke URAGO on Fri, 09 May 2003 17:06:23 +0900 It was downloaded from http://sourceforge.net/projects/sqlobject Upstream Author: Ian Bicking Copyright: PSF The Python Software Foundation License can be downloaded from http://www.opensource.org/licenses/PythonSoftFoundation.php SQLObject-3.1.0/debian/rules0000755000175000017500000000231510066344323015155 0ustar phdphd00000000000000#!/usr/bin/make -f # Sample debian/rules that uses debhelper. # GNU copyright 1997 to 1999 by Joey Hess. # Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 PYTHON=python configure: configure-stamp configure-stamp: dh_testdir #$(PYTHON) config_unix.py --prefix /usr #$(PYTHON) setup.py config touch configure-stamp build: build-stamp build-stamp: configure-stamp dh_testdir $(PYTHON) setup.py build touch build-stamp clean: dh_testdir dh_testroot rm -f build-stamp configure-stamp -$(PYTHON) setup.py clean --all dh_clean install: build dh_testdir dh_testroot dh_clean -k dh_installdirs $(PYTHON) setup.py install --prefix $(CURDIR)/debian/python-sqlobject/usr # Build architecture-independent files here. binary-indep: build install # We have nothing to do by default. # Build architecture-dependent files here. binary-arch: build install dh_testdir dh_testroot dh_installdocs -X.svn dh_installexamples -X.svn dh_installchangelogs dh_link dh_strip dh_compress dh_fixperms dh_makeshlibs -V dh_python dh_installdeb dh_gencontrol dh_md5sums dh_builddeb -X.svn binary: binary-indep binary-arch .PHONY: build clean binary-indep binary-arch binary install configure SQLObject-3.1.0/debian/examples0000644000175000017500000000000712224003267015627 0ustar phdphd00000000000000tests/ SQLObject-3.1.0/circle.yml0000644000175000017500000000042712753127445014652 0ustar phdphd00000000000000dependencies: cache_directories: - ~/.cache/pip override: - sudo apt-get -qq update - sudo apt-get install -y python-egenix-mxdatetime python-mysqldb python-psycopg2 - pip install -U pip - pip install -U tox tox-pyenv - pyenv local 2.6.8 2.7.10 3.4.3 SQLObject-3.1.0/.travis.yml0000644000175000017500000000124612753127445014777 0ustar phdphd00000000000000# Prefer docker container with setuid/sudo sudo: required language: python cache: pip addons: postgresql: "9.4" env: - TOXENV=py26-mysql - TOXENV=py27-mysql - TOXENV=py26-postgres - TOXENV=py27-postgres - TOXENV=py26-sqlite - TOXENV=py27-sqlite - TOXENV=py34-sqlite - TOXENV=py34-postgres - TOXENV=py34-mysqlclient - TOXENV=py27-flake8 - TOXENV=py34-flake8 before_install: - sudo apt-get -qq update - sudo apt-get install -y python-egenix-mxdatetime python-mysqldb python-psycopg2 install: pip install tox coveralls codecov matrix: fast_finish: true script: tox -e ${TOXENV} after_success: - cd sqlobject - coveralls - codecov SQLObject-3.1.0/requirements.txt0000644000175000017500000000027612752246540016151 0ustar phdphd00000000000000--install-option="--compile --optimize" FormEncode >= 1.1.1, != 1.3.0; python_version >= '2.6' and python_version < '3.0' FormEncode >= 1.3.1; python_version >= '3.4' PyDispatcher >= 2.0.4 SQLObject-3.1.0/PKG-INFO0000644000175000017500000000343712754657361013775 0ustar phdphd00000000000000Metadata-Version: 1.1 Name: SQLObject Version: 3.1.0 Summary: Object-Relational Manager, aka database wrapper Home-page: http://sqlobject.org/devel/ Author: Oleg Broytman Author-email: phd@phdru.name License: LGPL Download-URL: https://pypi.python.org/pypi/SQLObject/3.1.0 Description: SQLObject is a popular *Object Relational Manager* for providing an object interface to your database, with tables as classes, rows as instances, and columns as attributes. SQLObject includes a Python-object-based query language that makes SQL more abstract, and provides substantial database independence for applications. Supports MySQL, PostgreSQL, SQLite, Firebird, Sybase, MSSQL and MaxDB (SAPDB). Python 2.6, 2.7 or 3.4+ is required. For development see the projects at `SourceForge `_ and `GitHub `_. .. image:: https://travis-ci.org/sqlobject/sqlobject.svg?branch=master :target: https://travis-ci.org/sqlobject/sqlobject Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.4 Classifier: Topic :: Database Classifier: Topic :: Database :: Front-Ends Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires: FormEncode Requires: PyDispatcher SQLObject-3.1.0/requirements_docs.txt0000644000175000017500000000006312751516110017143 0ustar phdphd00000000000000-r requirements.txt buildutils kid >= 0.9.6 pudge SQLObject-3.1.0/MANIFEST.in0000644000175000017500000000101212753522777014422 0ustar phdphd00000000000000global-include .gitignore include MANIFEST.in ez_setup.py include .travis.yml circle.yml tox.ini include *.rst *.txt docs/LICENSE docs/*.rst include docs/rebuild include sqlobject/.coveragerc include sqlobject/maxdb/readme.txt recursive-include debian * recursive-include docs *.css *.html *.js *.gif *.png *.py *.txt recursive-include sqlobject/tests *.py recursive-include sqlobject/include/tests *.py recursive-include sqlobject/inheritance/tests *.py recursive-include sqlobject/versioning/test *.py prune docs/_build SQLObject-3.1.0/ez_setup.py0000644000175000017500000003016212747417740015100 0ustar phdphd00000000000000#!/usr/bin/env python """ Setuptools bootstrapping installer. Maintained at https://github.com/pypa/setuptools/tree/bootstrap. Run this script to install or upgrade setuptools. """ import os import shutil import sys import tempfile import zipfile import optparse import subprocess import platform import textwrap import contextlib import json import codecs from distutils import log try: from urllib.request import urlopen from urllib.parse import urljoin except ImportError: from urllib2 import urlopen from urlparse import urljoin try: from site import USER_SITE except ImportError: USER_SITE = None LATEST = object() DEFAULT_VERSION = LATEST DEFAULT_URL = "https://pypi.io/packages/source/s/setuptools/" DEFAULT_SAVE_DIR = os.curdir def _python_cmd(*args): """ Execute a command. Return True if the command succeeded. """ args = (sys.executable,) + args return subprocess.call(args) == 0 def _install(archive_filename, install_args=()): """Install Setuptools.""" with archive_context(archive_filename): # installing log.warn('Installing Setuptools') if not _python_cmd('setup.py', 'install', *install_args): log.warn('Something went wrong during the installation.') log.warn('See the error message above.') # exitcode will be 2 return 2 def _build_egg(egg, archive_filename, to_dir): """Build Setuptools egg.""" with archive_context(archive_filename): # building an egg log.warn('Building a Setuptools egg in %s', to_dir) _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir) # returning the result log.warn(egg) if not os.path.exists(egg): raise IOError('Could not build the egg.') class ContextualZipFile(zipfile.ZipFile): """Supplement ZipFile class to support context manager for Python 2.6.""" def __enter__(self): return self def __exit__(self, type, value, traceback): self.close() def __new__(cls, *args, **kwargs): """Construct a ZipFile or ContextualZipFile as appropriate.""" if hasattr(zipfile.ZipFile, '__exit__'): return zipfile.ZipFile(*args, **kwargs) return super(ContextualZipFile, cls).__new__(cls) @contextlib.contextmanager def archive_context(filename): """ Unzip filename to a temporary directory, set to the cwd. The unzipped target is cleaned up after. """ tmpdir = tempfile.mkdtemp() log.warn('Extracting in %s', tmpdir) old_wd = os.getcwd() try: os.chdir(tmpdir) with ContextualZipFile(filename) as archive: archive.extractall() # going in the directory subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0]) os.chdir(subdir) log.warn('Now working in %s', subdir) yield finally: os.chdir(old_wd) shutil.rmtree(tmpdir) def _do_download(version, download_base, to_dir, download_delay): """Download Setuptools.""" py_desig = 'py{sys.version_info[0]}.{sys.version_info[1]}'.format(sys=sys) tp = 'setuptools-{version}-{py_desig}.egg' egg = os.path.join(to_dir, tp.format(**locals())) if not os.path.exists(egg): archive = download_setuptools(version, download_base, to_dir, download_delay) _build_egg(egg, archive, to_dir) sys.path.insert(0, egg) # Remove previously-imported pkg_resources if present (see # https://bitbucket.org/pypa/setuptools/pull-request/7/ for details). if 'pkg_resources' in sys.modules: _unload_pkg_resources() import setuptools setuptools.bootstrap_install_from = egg def use_setuptools( version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=DEFAULT_SAVE_DIR, download_delay=15): """ Ensure that a setuptools version is installed. Return None. Raise SystemExit if the requested version or later cannot be installed. """ version = _resolve_version(version) to_dir = os.path.abspath(to_dir) # prior to importing, capture the module state for # representative modules. rep_modules = 'pkg_resources', 'setuptools' imported = set(sys.modules).intersection(rep_modules) try: import pkg_resources pkg_resources.require("setuptools>=" + version) # a suitable version is already installed return except ImportError: # pkg_resources not available; setuptools is not installed; download pass except pkg_resources.DistributionNotFound: # no version of setuptools was found; allow download pass except pkg_resources.VersionConflict as VC_err: if imported: _conflict_bail(VC_err, version) # otherwise, unload pkg_resources to allow the downloaded version to # take precedence. del pkg_resources _unload_pkg_resources() return _do_download(version, download_base, to_dir, download_delay) def _conflict_bail(VC_err, version): """ Setuptools was imported prior to invocation, so it is unsafe to unload it. Bail out. """ conflict_tmpl = textwrap.dedent(""" The required version of setuptools (>={version}) is not available, and can't be installed while this script is running. Please install a more recent version first, using 'easy_install -U setuptools'. (Currently using {VC_err.args[0]!r}) """) msg = conflict_tmpl.format(**locals()) sys.stderr.write(msg) sys.exit(2) def _unload_pkg_resources(): sys.meta_path = [ importer for importer in sys.meta_path if importer.__class__.__module__ != 'pkg_resources.extern' ] del_modules = [ name for name in sys.modules if name.startswith('pkg_resources') ] for mod_name in del_modules: del sys.modules[mod_name] def _clean_check(cmd, target): """ Run the command to download target. If the command fails, clean up before re-raising the error. """ try: subprocess.check_call(cmd) except subprocess.CalledProcessError: if os.access(target, os.F_OK): os.unlink(target) raise def download_file_powershell(url, target): """ Download the file at url to target using Powershell. Powershell will validate trust. Raise an exception if the command cannot complete. """ target = os.path.abspath(target) ps_cmd = ( "[System.Net.WebRequest]::DefaultWebProxy.Credentials = " "[System.Net.CredentialCache]::DefaultCredentials; " '(new-object System.Net.WebClient).DownloadFile("%(url)s", "%(target)s")' % locals() ) cmd = [ 'powershell', '-Command', ps_cmd, ] _clean_check(cmd, target) def has_powershell(): """Determine if Powershell is available.""" if platform.system() != 'Windows': return False cmd = ['powershell', '-Command', 'echo test'] with open(os.path.devnull, 'wb') as devnull: try: subprocess.check_call(cmd, stdout=devnull, stderr=devnull) except Exception: return False return True download_file_powershell.viable = has_powershell def download_file_curl(url, target): cmd = ['curl', url, '--location', '--silent', '--output', target] _clean_check(cmd, target) def has_curl(): cmd = ['curl', '--version'] with open(os.path.devnull, 'wb') as devnull: try: subprocess.check_call(cmd, stdout=devnull, stderr=devnull) except Exception: return False return True download_file_curl.viable = has_curl def download_file_wget(url, target): cmd = ['wget', url, '--quiet', '--output-document', target] _clean_check(cmd, target) def has_wget(): cmd = ['wget', '--version'] with open(os.path.devnull, 'wb') as devnull: try: subprocess.check_call(cmd, stdout=devnull, stderr=devnull) except Exception: return False return True download_file_wget.viable = has_wget def download_file_insecure(url, target): """Use Python to download the file, without connection authentication.""" src = urlopen(url) try: # Read all the data in one block. data = src.read() finally: src.close() # Write all the data in one block to avoid creating a partial file. with open(target, "wb") as dst: dst.write(data) download_file_insecure.viable = lambda: True def get_best_downloader(): downloaders = ( download_file_powershell, download_file_curl, download_file_wget, download_file_insecure, ) viable_downloaders = (dl for dl in downloaders if dl.viable()) return next(viable_downloaders, None) def download_setuptools( version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=DEFAULT_SAVE_DIR, delay=15, downloader_factory=get_best_downloader): """ Download setuptools from a specified location and return its filename. `version` should be a valid setuptools version number that is available as an sdist for download under the `download_base` URL (which should end with a '/'). `to_dir` is the directory where the egg will be downloaded. `delay` is the number of seconds to pause before an actual download attempt. ``downloader_factory`` should be a function taking no arguments and returning a function for downloading a URL to a target. """ version = _resolve_version(version) # making sure we use the absolute path to_dir = os.path.abspath(to_dir) zip_name = "setuptools-%s.zip" % version url = download_base + zip_name saveto = os.path.join(to_dir, zip_name) if not os.path.exists(saveto): # Avoid repeated downloads log.warn("Downloading %s", url) downloader = downloader_factory() downloader(url, saveto) return os.path.realpath(saveto) def _resolve_version(version): """ Resolve LATEST version """ if version is not LATEST: return version meta_url = urljoin(DEFAULT_URL, '/pypi/setuptools/json') resp = urlopen(meta_url) with contextlib.closing(resp): try: charset = resp.info().get_content_charset() except Exception: # Python 2 compat; assume UTF-8 charset = 'UTF-8' reader = codecs.getreader(charset) doc = json.load(reader(resp)) return str(doc['info']['version']) def _build_install_args(options): """ Build the arguments to 'python setup.py install' on the setuptools package. Returns list of command line arguments. """ return ['--user'] if options.user_install else [] def _parse_args(): """Parse the command line for options.""" parser = optparse.OptionParser() parser.add_option( '--user', dest='user_install', action='store_true', default=False, help='install in user site package') parser.add_option( '--download-base', dest='download_base', metavar="URL", default=DEFAULT_URL, help='alternative URL from where to download the setuptools package') parser.add_option( '--insecure', dest='downloader_factory', action='store_const', const=lambda: download_file_insecure, default=get_best_downloader, help='Use internal, non-validating downloader' ) parser.add_option( '--version', help="Specify which version to download", default=DEFAULT_VERSION, ) parser.add_option( '--to-dir', help="Directory to save (and re-use) package", default=DEFAULT_SAVE_DIR, ) options, args = parser.parse_args() # positional arguments are ignored return options def _download_args(options): """Return args for download_setuptools function from cmdline args.""" return dict( version=options.version, download_base=options.download_base, downloader_factory=options.downloader_factory, to_dir=options.to_dir, ) def main(): """Install or upgrade setuptools and EasyInstall.""" options = _parse_args() archive = download_setuptools(**_download_args(options)) return _install(archive, _build_install_args(options)) if __name__ == '__main__': sys.exit(main())