rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def __sqlrepr__(self, db): s = sqlrepr(self.expr, db) | 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 = sqlrepr(self.expr, db)[1:-1] | def __init__(self, expr): self.expr = expr |
return s.replace('%', '\\%') | s = s.replace('%', '\\%') | def __sqlrepr__(self, db): s = sqlrepr(self.expr, db) if db in ('postgres', 'mysql'): return s.replace('%', '\\%') else: return s.replace('%', '%%') |
return s.replace('%', '%%') | s = s.replace('%', '%%') return "'%s%s%s'" % (self.prefix, s, self.postfix) | def __sqlrepr__(self, db): s = sqlrepr(self.expr, db) if db in ('postgres', 'mysql'): return s.replace('%', '\\%') else: return s.replace('%', '%%') |
return ' '.join(['%s = %s' % | return ' AND '.join(['%s = %s' % | def _SO_columnClause(self, soClass, kw): return ' '.join(['%s = %s' % (soClass._SO_columnDict[key].dbName, self.sqlrepr(value)) for key, value in kw.items()]) |
assert name not in dir(soClass), ( "The class %s.%s already has a variable or method %r, you cannot " "add the column %r" % (soClass.__module__, soClass.__name__, name, name)) | parent_columns = [] for base in soClass.__bases__: if hasattr(base, "sqlmeta"): parent_columns.extend(base.sqlmeta.columns.keys()) if name in dir(soClass): assert name in parent_columns, ( "The class %s.%s already has a variable or method %r, you cannot " "add the column %r" % (soClass.__module__, soClass.__name__, nam... | 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', ( "... |
self._parent = parentClass(kw=parent_kw) | self._parent = parentClass(kw=parent_kw, connection=self._connection) | def _create(self, id, **kw): |
dsn_dict["port"] = port | if psycopg.__version__.split('.')[0] == '1': dsn_dict["port"] = str(port) else: dsn_dict["port"] = port | def __init__(self, dsn=None, host=None, port=None, db=None, user=None, password=None, usePygresql=False, unicodeCols=False, **kw): global psycopg, pgdb self.usePygresql = usePygresql if usePygresql: if pgdb is None: import pgdb self.module = pgdb else: if psycopg is None: try: import psycopg2 as psycopg except ImportEr... |
if self.verbose > 1: | if self.options.verbose > 1: | 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... |
if end: return "SET ROWCOUNT %i %s SET ROWCOUNT 0" % (end, query) | def _queryAddLimitOffset(self, query, start, end): # XXX Sybase doesn't support LIMIT return query | |
while 1: | for c in range(0, 3): | def _executeRetry(self, conn, cursor, query): while 1: try: if self.need_unicode: # For MysqlDB 1.2.1 and later, we go # encoding->unicode->charset (in the mysql db) myquery = unicode(query, self.encoding) return cursor.execute(myquery) else: return cursor.execute(query) except MySQLdb.OperationalError, e: if e.args[0]... |
if e.args[0] == 2013: | if e.args[0] in (2006, 2013): if c == 2: raise OperationalError(ErrorMessage(e)) | def _executeRetry(self, conn, cursor, query): while 1: try: if self.need_unicode: # For MysqlDB 1.2.1 and later, we go # encoding->unicode->charset (in the mysql db) myquery = unicode(query, self.encoding) return cursor.execute(myquery) else: return cursor.execute(query) except MySQLdb.OperationalError, e: if e.args[0]... |
return {} | return None, {} | def config_from_egg(self, egg_spec, warn_no_sqlobject=True): import pkg_resources pkg_resources.require(egg_spec) dist = pkg_resources.working_set.find(pkg_resources.Requirement(egg_spec)) if not dist.has_metadata('sqlobject.txt'): if warn_no_sqlobject: print 'No sqlobject.txt in %s egg info' % egg_spec return {} resul... |
print 'Warning: %s appears more than one in sqlobject.txt' % name | print 'Warning: %s appears more than once in sqlobject.txt' % name | def config_from_egg(self, egg_spec, warn_no_sqlobject=True): import pkg_resources pkg_resources.require(egg_spec) dist = pkg_resources.working_set.find(pkg_resources.Requirement(egg_spec)) if not dist.has_metadata('sqlobject.txt'): if warn_no_sqlobject: print 'No sqlobject.txt in %s egg info' % egg_spec return {} resul... |
dsn_dict["port"] = str(port) | dsn_dict["port"] = port | def __init__(self, dsn=None, host=None, port=None, db=None, user=None, password=None, usePygresql=False, unicodeCols=False, **kw): global psycopg, pgdb self.usePygresql = usePygresql if usePygresql: if pgdb is None: import pgdb self.module = pgdb else: if psycopg is None: try: import psycopg2 as psycopg except ImportEr... |
return_value = fn(self, *args, **kwargs) lock.release() return return_value | try: return fn(self, *args, **kwargs) finally: lock.release() | def _wrapper(self, *args, **kwargs): lock.acquire() return_value = fn(self, *args, **kwargs) lock.release() return return_value |
def _queryInsertID(self, conn, table, idName, id, names, values): | def _queryInsertID(self, conn, soInstance, id, names, values): | def _queryInsertID(self, conn, table, idName, id, names, values): """Firebird uses 'generators' to create new ids for a table. The users needs to create a generator named GEN_<tablename> for each table this method to work.""" table = soInstance._table idName = soInstance._idName sequenceName = getattr(soInstance, '_idS... |
usage(1) | sys.exit("Usage: %s [-d|--database all|type] [-v[v]] [--extra-verbose|--super-verbose] [--inserts] [--coverage]" % sys.argv[0]) | def main(): import unittest from getopt import getopt, GetoptError try: options, arguments = getopt(sys.argv[1:], "d:v", ["database=", "extra-verbose", "super-verbose", "inserts", "coverage"]) except GetoptError: usage(1) dbs = [] newArgs = [] doCoverage = False verbose = 0 for option, value in options: if option in... |
assert id is not None, 'None is not a possible id for %s' % cls.__name | assert id is not None, 'None is not a possible id for %s' % cls.__name__ | def get(cls, id, connection=None, selectResults=None): |
self._obsolete = False | def __init__(self, dbConnection): self._dbConnection = dbConnection self._connection = dbConnection.getConnection() self._dbConnection._setAutoCommit(self._connection, 0) self.cache = CacheSet(cache=dbConnection.doCache) self._obsolete = False | |
return kw['name'] | return self.kw['name'] | def _get_name(self): return kw['name'] |
SOCol.__init__(self, **kw) | super(SOStringLikeCol, self).__init__(**kw) | def __init__(self, **kw): self.length = popKey(kw, 'length') self.varchar = popKey(kw, 'varchar', 'auto') self.char_binary = popKey(kw, '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.varcha... |
SOKeyCol.__init__(self, **kw) | super(SOForeignKey, self).__init__(**kw) | def __init__(self, **kw): foreignKey = kw['foreignKey'] style = kw['soClass'].sqlmeta.style if not kw.get('name'): kw['name'] = style.instanceAttrToIDAttr(style.pythonClassToAttr(foreignKey)) else: kw['origName'] = kw['name'] if not kw['name'].upper().endswith('ID'): kw['name'] = style.instanceAttrToIDAttr(kw['name']) ... |
KeyCol.__init__(self, foreignKey=foreignKey, **kw) | super(ForeignKey, self).__init__(foreignKey=foreignKey, **kw) | def __init__(self, foreignKey=None, **kw): KeyCol.__init__(self, foreignKey=foreignKey, **kw) |
SOCol.__init__(self, **kw) | super(SOEnumCol, self).__init__(**kw) | def __init__(self, **kw): self.enumValues = popKey(kw, 'enumValues', None) assert self.enumValues is not None, \ 'You must provide an enumValues keyword argument' SOCol.__init__(self, **kw) |
SOCol.__init__(self, **kw) | super(SODateTimeCol, self).__init__(**kw) | def __init__(self, **kw): datetimeFormat = popKey(kw, 'datetimeFormat') if datetimeFormat: self.datetimeFormat = datetimeFormat SOCol.__init__(self, **kw) |
SOCol.__init__(self, **kw) | super(SODateCol, self).__init__(**kw) | def __init__(self, **kw): dateFormat = popKey(kw, 'dateFormat') if dateFormat: self.dateFormat = dateFormat SOCol.__init__(self, **kw) |
SOCol.__init__(self, **kw) | super(SOTimeCol, self).__init__(**kw) | def __init__(self, **kw): timeFormat = popKey(kw, 'timeFormat') if timeFormat: self.timeFormat = timeFormat SOCol.__init__(self, **kw) |
SOCol.__init__(self, **kw) | super(SODecimalCol, self).__init__(**kw) | def __init__(self, **kw): self.size = popKey(kw, 'size', NoDefault) assert self.size is not NoDefault, \ "You must give a size argument" self.precision = popKey(kw, 'precision', NoDefault) assert self.precision is not NoDefault, \ "You must give a precision argument" SOCol.__init__(self, **kw) |
SODecimalCol.__init__(self, **kw) | super(SOCurrencyCol, self).__init__(**kw) | def __init__(self, **kw): pushKey(kw, 'size', 10) pushKey(kw, 'precision', 2) SODecimalCol.__init__(self, **kw) |
SOBLOBCol.__init__(self, **kw) | super(SOPickleCol, self).__init__(**kw) | def __init__(self, **kw): self.pickleProtocol = popKey(kw, 'pickleProtocol', 1) SOBLOBCol.__init__(self, **kw) |
if value: | if value is None: return None elif value: | def fromPython(self, value, state): if value: return sqlbuilder.TRUE else: return sqlbuilder.FALSE |
if not value: | if value is None: return None elif not value: | def toPython(self, value, state): if not value: return sqlbuilder.FALSE else: return sqlbuilder.TRUE |
user=None, passwd=None, usePygresql=False, | user=None, passwd=None, usePygresql=False, unicodeCols=False, | def __init__(self, dsn=None, host=None, port=None, db=None, user=None, passwd=None, usePygresql=False, **kw): global psycopg, pgdb self.usePygresql = usePygresql if usePygresql: if pgdb is None: import pgdb self.module = pgdb else: if psycopg is None: import psycopg self.module = psycopg |
import firebird _firebird = firebird del firebird | import firebird as _firebird | def _warn(msg): import warnings warnings.warn(msg, DeprecationWarning, stacklevel=2) |
_firebird.builder()(*args, **kw) | return _firebird.builder()(*args, **kw) | def FirebirdConnection(*args, **kw): _warn('FirebirdConnection is deprecated; use connectionForURI("firebird://...") or "from sqlobject.firebird import builder; FirebirdConnection = builder()"') _firebird.builder()(*args, **kw) |
import mysql _mysql = mysql del mysql | import mysql as _mysql | def FirebirdConnection(*args, **kw): _warn('FirebirdConnection is deprecated; use connectionForURI("firebird://...") or "from sqlobject.firebird import builder; FirebirdConnection = builder()"') _firebird.builder()(*args, **kw) |
_mysql.builder()(*args, **kw) | return _mysql.builder()(*args, **kw) | def MySQLConnection(*args, **kw): _warn('MySQLConnection is deprecated; use connectionForURI("mysql://...") or "from sqlobject.mysql import builder; MySQLConnection = builder()"') _mysql.builder()(*args, **kw) |
import postgres _postgres = postgres del postgres | import postgres as _postgres | def MySQLConnection(*args, **kw): _warn('MySQLConnection is deprecated; use connectionForURI("mysql://...") or "from sqlobject.mysql import builder; MySQLConnection = builder()"') _mysql.builder()(*args, **kw) |
_postgres.builder()(*args, **kw) | return _postgres.builder()(*args, **kw) | def PostgresConnection(*args, **kw): _warn('PostgresConnection is deprecated; use connectionForURI("postgres://...") or "from sqlobject.postgres import builder; PostgresConnection = builder()"') _postgres.builder()(*args, **kw) |
import sqlite _sqlite = sqlite del sqlite | import sqlite as _sqlite | def PostgresConnection(*args, **kw): _warn('PostgresConnection is deprecated; use connectionForURI("postgres://...") or "from sqlobject.postgres import builder; PostgresConnection = builder()"') _postgres.builder()(*args, **kw) |
_sqlite.builder()(*args, **kw) | return _sqlite.builder()(*args, **kw) | def SQLiteConnection(*args, **kw): _warn('SQLiteConnection is deprecated; use connectionForURI("sqlite://...") or "from sqlobject.sqlite import builder; SQLiteConnection = builder()"') _sqlite.builder()(*args, **kw) |
import dbm _dbm = dbm del dbm | import dbm as _dbm | def SQLiteConnection(*args, **kw): _warn('SQLiteConnection is deprecated; use connectionForURI("sqlite://...") or "from sqlobject.sqlite import builder; SQLiteConnection = builder()"') _sqlite.builder()(*args, **kw) |
_dbm.builder()(*args, **kw) | return _dbm.builder()(*args, **kw) | def DBMConnection(*args, **kw): _warn('DBMConnection is deprecated; use connectionForURI("dbm://...") or "from sqlobject.dbm import builder; DBMConnection = builder()"') _dbm.builder()(*args, **kw) |
import sybase _sybase = sybase del sybase | import sybase as _sybase | def DBMConnection(*args, **kw): _warn('DBMConnection is deprecated; use connectionForURI("dbm://...") or "from sqlobject.dbm import builder; DBMConnection = builder()"') _dbm.builder()(*args, **kw) |
_sybase.builder()(*args, **kw) | return _sybase.builder()(*args, **kw) | def SybaseConnection(*args, **kw): _warn('SybaseConnection is deprecated; use connectionForURI("sybase://...") or "from sqlobject.sybase import builder; SybaseConnection = builder()"') _sybase.builder()(*args, **kw) |
import maxdb _maxdb = maxdb del maxdb | import maxdb as _maxdb | def SybaseConnection(*args, **kw): _warn('SybaseConnection is deprecated; use connectionForURI("sybase://...") or "from sqlobject.sybase import builder; SybaseConnection = builder()"') _sybase.builder()(*args, **kw) |
("'", "''"), | ("'", "\\'"), | def __repr__(self): if self: return 'TRUE' else: return 'FALSE' |
% (obj.__name__, col.name, desc, repr(value)) | % (obj, col.name, desc, value) | def __init__(self, desc, obj, col, value, *args): self.desc = desc self.col = col |
raise BadValue("accepts only values in %s" % self.list, | raise BadValue("accepts only values in %s" % repr(self.list), | def __call__(self, obj, col, value): if value not in self.list: raise BadValue("accepts only values in %s" % self.list, obj, col, value) |
kw['default'] = getattr(sqlbuilder.const, defaultstr) | kw['default'] = self.defaultFromSchema(colClass, defaultstr) elif not notnull: kw['default'] = None | (SELECT substring(d.adsrc for 128) FROM pg_catalog.pg_attrdef d |
return value.strftime("'%Y-%m-%d %H:%M:%s'") | return value.strftime("'%Y-%m-%d %H:%M:%S'") | def DateTimeConverter(value, db): return value.strftime("'%Y-%m-%d %H:%M:%s'") |
return value.strftime("'%H:%M:%s'") | return value.strftime("'%H:%M:%S'") | def TimeConverter(value, db): return value.strftime("'%H:%M:%s'") |
def __init__(self, makeDefault=False, **kw): | def __init__(self, **kw): self.makeDefault = popKey(kw, 'makeDefault', False) | def __init__(self, makeDefault=False, **kw): SOMultipleJoin.__init__(self, **kw) self.makeDefault = makeDefault |
self.makeDefault = makeDefault | def __init__(self, makeDefault=False, **kw): SOMultipleJoin.__init__(self, **kw) self.makeDefault = makeDefault | |
assert name in parent_columns, ( | assert name in parent_columns or name == "childName", ( | 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', ( "... |
self.soClass = None | self.soClass = soClass | def __init__(self, name, soClass, dbName=None, default=NoDefault, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=NoDefault, notNone=NoDefault, unique=NoDefault, sqlType=None, columnDef=None, validator=None, immutable=False, cascade=None, lazy=False, noCache=False, forceDBName=Fa... |
other = findClass(self.foreignKey) | print [self, self.soClass] other = findClass(self.foreignKey, self.soClass.sqlmeta.registry) | def postgresCreateSQL(self): sql = SOKeyCol.postgresCreateSQL(self) other = findClass(self.foreignKey) tName = other.sqlmeta.table idName = 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... |
for registryClass in allClasses: if registryClass.sqlmeta.table in tablesDict: currentClass = registryClass.sqlmeta.parentClass while currentClass: if tableRegistry.has_key(currentClass): tableRegistry[registryClass] = currentClass | tableRegistryCopy = tableRegistry.copy() for childClass in tableRegistryCopy: if childClass not in tableRegistry: continue currentClass = childClass while currentClass: if tableRegistryCopy.has_key(currentClass): if currentClass in tableRegistry: | def __init__(self, sourceClass, clause, clauseTables=None, **ops): if clause is None or isinstance(clause, str) and clause == 'all': clause = sqlbuilder.SQLTrueClause tablesDict = sqlbuilder.tablesUsedDict(clause) tablesDict[sourceClass.sqlmeta.table] = 1 orderBy = ops.get('orderBy') if orderBy and not isinstance(order... |
currentClass = currentClass.sqlmeta.parentClass | tableRegistry[childClass] = currentClass currentClass = currentClass.sqlmeta.parentClass | def __init__(self, sourceClass, clause, clauseTables=None, **ops): if clause is None or isinstance(clause, str) and clause == 'all': clause = sqlbuilder.SQLTrueClause tablesDict = sqlbuilder.tablesUsedDict(clause) tablesDict[sourceClass.sqlmeta.table] = 1 orderBy = ops.get('orderBy') if orderBy and not isinstance(order... |
for key in ("connect_time", "compress", "named_pipe", "use_unicode", | for key in ("connect_timeout", "compress", "named_pipe", "use_unicode", | def __init__(self, db, user, password='', host='localhost', port=None, **kw): global MySQLdb if MySQLdb is None: import MySQLdb self.module = MySQLdb self.host = host self.port = port self.db = db self.user = user self.password = password if kw.has_key('client_encoding'): self.client_encoding = col.popKey(kw, 'client_e... |
value = fromPython(value, self._SO_validatorState) toUpdate[name] = value | dbValue = fromPython(value, self._SO_validatorState) else: dbValue = value toUpdate[name] = dbValue | def set(self, **kw): # set() is used to update multiple values at once, # potentially with one SQL statement if possible. |
def __init__(self, db, user, passwd='', host='localhost', **kw): | def __init__(self, db, user, passwd='', host='localhost', port=None, **kw): | def __init__(self, db, user, passwd='', host='localhost', **kw): global MySQLdb if MySQLdb is None: import MySQLdb self.module = MySQLdb self.host = host self.db = db self.user = user self.password = passwd DBAPI.__init__(self, **kw) |
return MySQLdb.connect(host=self.host, db=self.db, | return MySQLdb.connect(host=self.host, port=self.port, db=self.db, | def makeConnection(self): return MySQLdb.connect(host=self.host, db=self.db, user=self.user, passwd=self.password) |
items.append((col.name, getattr(self, col.name))) | items.append((col.name, 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, getattr(self, col.name))) return items |
installedDBFilename = os.path.join(os.getcwd(), 'dbs_data.tmp') | installedDBFilename = os.path.join(getcwd(), 'dbs_data.tmp') | def setupClass(soClasses): """ 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 wil... |
SHOW_COLUMNS=("select 'column' = COL_NAME(id, colid) " "from syscolumns where id = OBJECT_ID(%s)") | SHOW_COLUMNS=('SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS ' 'WHERE TABLE_NAME = \'%s\'') | def delColumn(self, tableName, column): self.query('ALTER TABLE %s DROP COLUMN %s' % (tableName, column.dbName)) |
for field, t, nullAllowed, key, default, extra in colData: | for field, t, nullAllowed, default in colData: | def columnsFromSchema(self, tableName, soClass): colData = self.queryAll(self.SHOW_COLUMNS % tableName) results = [] for field, t, nullAllowed, key, default, extra in colData: if field == 'id': continue colClass, kw = self.guessClass(t) kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['notNone'] = not ... |
sql += '\n' + cls.createJoinTablesSQL(connection=conn) | join_sql = cls.createJoinTablesSQL(connection=conn) if join_sql: sql = ';\n' + join_sql | def createTableSQL(cls, createJoinTables=True, createIndexes=True, connection=None): conn = connection or cls._connection sql, constraints = conn.createTableSQL(cls) if createJoinTables: sql += '\n' + cls.createJoinTablesSQL(connection=conn) if createIndexes: sql += '\n' + cls.createIndexesSQL(connection=conn) return s... |
sql += '\n' + cls.createIndexesSQL(connection=conn) | index_sql = cls.createIndexesSQL(connection=conn) if index_sql: sql += ';\n' + index_sql | def createTableSQL(cls, createJoinTables=True, createIndexes=True, connection=None): conn = connection or cls._connection sql, constraints = conn.createTableSQL(cls) if createJoinTables: sql += '\n' + cls.createJoinTablesSQL(connection=conn) if createIndexes: sql += '\n' + cls.createIndexesSQL(connection=conn) return s... |
for (table,) in self.queryAll('SHOW TABLES'): if table.lower() == tableName.lower(): return True return False | try: self.query('DESCRIBE %s' % (tableName)) return True except MySQLdb.ProgrammingError, e: if e.args[0] == 1146: return False raise | def tableExists(self, tableName): for (table,) in self.queryAll('SHOW TABLES'): if table.lower() == tableName.lower(): return True return False |
dt1 = DateTime1(col1=_now, col2=_now) assert isinstance(dt1.col1, date) assert isinstance(dt1.col2, datetime) | _today = date.today() dt1 = DateTime1(col1=_now, col2=_today) | def test_dateTime(): setupClass(DateTime1) _now = now() dt1 = DateTime1(col1=_now, col2=_now) assert isinstance(dt1.col1, date) assert isinstance(dt1.col2, datetime) |
today_str = _now.strftime("%Y-%m-%d") now_str = _now.strftime("%Y-%m-%d %T") assert str(dt1.col1) == today_str assert str(dt1.col2) == now_str | 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 == int(_now.second) assert isinstance(dt1.col2, date) assert dt1.col2.year == _today... | def test_dateTime(): setupClass(DateTime1) _now = now() dt1 = DateTime1(col1=_now, col2=_now) assert isinstance(dt1.col1, date) assert isinstance(dt1.col2, datetime) |
col1 = DateCol() col2 = DateTimeCol() | col1 = DateTimeCol() col2 = DateCol(dateFormat="%Y-%m-%d %H:%M:%S") | def test_dateTime(): setupClass(DateTime1) _now = now() dt1 = DateTime1(col1=_now, col2=_now) assert isinstance(dt1.col1, date) assert isinstance(dt1.col2, datetime) |
today_str = _now.strftime("%Y-%m-%d 00:00:00.00") now_str = _now.strftime("%Y-%m-%d %T.00") assert str(dt2.col1) == today_str assert str(dt2.col2) == now_str | assert dt2.col2.year == _now.year assert dt2.col2.month == _now.month assert dt2.col2.day == _now.day assert dt2.col1.hour == _now.hour assert dt2.col1.minute == _now.minute assert dt2.col1.second == int(_now.second) | def test_mxDateTime(): setupClass(DateTime2) _now = now() dt2 = DateTime2(col1=_now, col2=_now) assert isinstance(dt2.col1, col.DateTimeType) assert isinstance(dt2.col2, col.DateTimeType) |
warning_level = warning | global warnings_leve, exception_level warnings_level = warning | 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 ``exceptio... |
dsn = [] if db: dsn.append('dbname=%s' % db) if user: dsn.append('user=%s' % user) if passwd: dsn.append('password=%s' % passwd) if host: dsn.append('host=%s' % host) if port: dsn.append('port=%s' % port) dsn = ' '.join(dsn) | if usePygresql: dsn = '' if host: dsn += host dsn += ':' if db: dsn += db dsn += ':' if user: dsn += user dsn += ':' if passwd: dsn += passwd else: dsn = [] if db: dsn.append('dbname=%s' % db) if user: dsn.append('user=%s' % user) if passwd: dsn.append('password=%s' % passwd) if host: dsn.append('host=%s' % host) dsn ... | def __init__(self, dsn=None, host=None, port=None, db=None, user=None, passwd=None, usePygresql=False, **kw): global psycopg, pgdb if usePygresql: if pgdb is None: import pgdb self.module = pgdb else: if psycopg is None: import psycopg self.module = psycopg |
warnings.warn(msg, warnings.DeprecationWarning, stacklevel=2) | warnings.warn(msg, DeprecationWarning, stacklevel=2) | def _warn(msg): import warnings warnings.warn(msg, warnings.DeprecationWarning, stacklevel=2) |
if isinstance(value, type) and issubclass(value, (Col, SOCol)): | if isinstance(value, type) and (issubclass(value, Col) or issubclass(value, SOCol)): | def pushKey(kw, name, value): if not kw.has_key(name): kw[name] = value |
for id, value in self.expiredCache: | for id, value in self.expiredCache.items(): | def allIDs(self): if self.doCache: all = self.cache.keys() else: all = [] for id, value in self.expiredCache: if value(): all.append(id) return all |
def delColumn(sqlmeta, column, changeSchema=False, connection=None): | def delColumn(cls, column, changeSchema=False, connection=None): sqlmeta = cls | def delColumn(sqlmeta, column, changeSchema=False, connection=None): soClass = sqlmeta.soClass if isinstance(column, str): column = sqlmeta.columns[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... |
cur.execute('CREATE DATABASE %s TEMPLATE=template0' % self.db) | cur.execute('CREATE DATABASE %s' % self.db) | def createEmptyDatabase(self): # 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.usePygresql: dsn = '%s:template1:%s:%s' % ( self.host or '', self.user or '', self.password or '') else: dsn = 'dbname=te... |
opts = {'autocommit': autoCommit} if 'encoding' in kw: opts['encoding'] = popKey(kw, 'encoding') if 'mode' in kw: opts['mode'] = int(popKey(kw, 'mode'), 0) if 'timeout' in kw: opts['timeout'] = float(popKey(kw, 'timeout')) | def __init__(self, filename, autoCommit=1, **kw): global sqlite if sqlite is None: import sqlite self.module = sqlite self.filename = filename # full path to sqlite-db-file if not autoCommit and not kw.has_key('pool'): # Pooling doesn't work with transactions... kw['pool'] = 0 # use only one connection for sqlite - su... | |
self._conn = sqlite.connect(self.filename, autocommit=autoCommit) | self._conn = sqlite.connect(self.filename, **opts) | def __init__(self, filename, autoCommit=1, **kw): global sqlite if sqlite is None: import sqlite self.module = sqlite self.filename = filename # full path to sqlite-db-file if not autoCommit and not kw.has_key('pool'): # Pooling doesn't work with transactions... kw['pool'] = 0 # use only one connection for sqlite - su... |
"read_default_file", "read_default_group"): | "read_default_file", "read_default_group", "charset"): | def __init__(self, db, user, password='', host='localhost', port=None, **kw): global MySQLdb if MySQLdb is None: import MySQLdb self.module = MySQLdb self.host = host self.port = port self.db = db self.user = user self.password = password if kw.has_key('client_encoding'): self.client_encoding = col.popKey(kw, 'client_e... |
return cursor.execute(query) | if self.need_unicode: myquery = unicode(query, self.encoding) return cursor.execute(myquery) else: return cursor.execute(query) | def _executeRetry(self, conn, cursor, query): while 1: try: return cursor.execute(query) except MySQLdb.OperationalError, e: if e.args[0] == 2013: # SERVER_LOST error if self.debug: self.printDebug(conn, str(e), 'ERROR') else: raise |
channel.queue_declare(queue="test-ack-queue") | channel.queue_declare(queue="test-ack-queue", exclusive=True) | def test_ack(self): """ Test basic ack/recover behaviour """ channel = self.channel channel.queue_declare(queue="test-ack-queue") reply = channel.basic_consume(queue="test-ack-queue", no_ack=False) queue = self.client.queue(reply.consumer_tag) |
channel.queue_declare(queue="test-requeue") | channel.queue_declare(queue="test-requeue", exclusive=True) | def test_recover_requeue(self): """ Test requeing on recovery """ channel = self.channel channel.queue_declare(queue="test-requeue") subscription = channel.basic_consume(queue="test-requeue", no_ack=False) queue = self.client.queue(subscription.consumer_tag) |
channel.basic_publish(exchange="amq.direct", routing_key="test-queue-1a", content=Content("consume_no_local")) channel.basic_publish(exchange="amq.direct", routing_key="test-queue-1b", content=Content("consume_no_local")) | channel.basic_publish(routing_key="test-queue-1a", content=Content("consume_no_local")) channel.basic_publish(routing_key="test-queue-1b", content=Content("consume_no_local")) | def test_consume_no_local(self): """ Test that the no_local flag is honoured in the consume method """ channel = self.channel #setup, declare two queues: channel.queue_declare(queue="test-queue-1a", exclusive=True) channel.queue_declare(queue="test-queue-1b", exclusive=True) #establish two consumers one of which exclud... |
recodeval = lambda s: encoder(decoder(xml.sax.saxutils.escape(s, {"\\t" : "\t"}))[0])[0] | recodeval = lambda s: encoder(decoder(xml.sax.saxutils.escape(s.replace("\\\\","\\").replace("\\t","\t")))[0])[0] | def makename(oldname): name = ""; nextBig = True; for x in oldname: if x == '_': nextBig = True; else: if nextBig: name += x.upper(); nextBig = False; else: name += x.lower(); return name; |
recodeattr = lambda s: encoder(decoder(xml.sax.saxutils.quoteattr(s))[0])[0] recodeval = lambda s: encoder(decoder(xml.sax.saxutils.escape(s.replace("\\\\","\\").replace("\\t","\t")))[0])[0] | recodeattr = lambda s: encoder(decoder(quoteattr(s))[0])[0] recodeval = lambda s: encoder(decoder(escape(s, {"\\\\":"\\","\\t":"\t"}))[0])[0] | def makename(oldname): name = ""; nextBig = True; for x in oldname: if x == '_': nextBig = True; else: if nextBig: name += x.upper(); nextBig = False; else: name += x.lower(); return name; |
elif type != None: | elif kind != None: | def __init__(self,ref=None,kind=None): |
if self._ref != None and icalcomponent_get_parent(self._ref) != 'NULL': | if self._ref != None and icalcomponent_get_parent(self._ref) != WrapperNULL: | def __del__(self): if self._ref != None and icalcomponent_get_parent(self._ref) != 'NULL': |
if(p == None or p== 'NULL'): | if(p == None or p== WrapperNULL): | def _prop_from_ref(self,p): |
if p !='NULL': | if p !=WrapperNULL: | def property(self, type): |
while p !='NULL': | while p !=WrapperNULL and p != None: | def properties(self,type='ANY'): """ Return a list of Property instances, each representing a property of the type 'type.' """ |
if prop_p == 'NULL': | if prop_p == WrapperNULL: | def add_property(self, prop): "Adds the property object to the component." if not isinstance(prop,Property): raise TypeError |
if icalproperty_get_parent(prop_p)=='NULL': | if icalproperty_get_parent(prop_p)==WrapperNULL: | def add_property(self, prop): "Adds the property object to the component." if not isinstance(prop,Property): raise TypeError |
while c != 'NULL': | while c != WrapperNULL and c != None: | def components(self,type='ANY'): comps = [] |
if inner == 'NULL': | if inner == WrapperNULL and inner != None: | def inner_component(self): inner = icalcomponent_get_inner(self._ref) |
if icalcomponent_get_parent(comp._ref) != 'NULL': | if icalcomponent_get_parent(comp._ref) != WrapperNULL: | def add_component(self, comp): "Adds a child component." |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.