index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
27,364
|
sqlobject.sqlbuilder
|
RLIKE
| null |
class RLIKE(LIKE):
op = "RLIKE"
op_db = {
'firebird': 'RLIKE',
'maxdb': 'RLIKE',
'mysql': 'RLIKE',
'postgres': '~',
'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)
|
(expr, string, escape=None)
|
27,398
|
sqlobject.sqlbuilder
|
__sqlrepr__
| null |
def __sqlrepr__(self, db):
return "(%s %s (%s))" % (
sqlrepr(self.expr, db), self._get_op(db), sqlrepr(self.string, db)
)
|
(self, db)
|
27,402
|
sqlobject.sqlbuilder
|
_get_op
| null |
def _get_op(self, db):
return self.op_db.get(db, 'LIKE')
|
(self, db)
|
27,406
|
sqlobject.sqlbuilder
|
execute
| null |
def execute(self, executor):
self.op = self._get_op(self.db)
return LIKE.execute(self, executor)
|
(self, executor)
|
27,411
|
sqlobject.joins
|
RelatedJoin
| null |
class RelatedJoin(MultipleJoin):
baseClass = SORelatedJoin
|
(otherClass=None, **kw)
|
27,416
|
sqlobject.col
|
SOBLOBCol
| null |
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"
|
(**kw)
|
27,417
|
sqlobject.col
|
__delete__
| null |
def __delete__(self, obj):
raise AttributeError("I can't be deleted from %r" % obj)
|
(self, obj)
|
27,418
|
sqlobject.col
|
__get__
| null |
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)
|
(self, obj, type=None)
|
27,419
|
sqlobject.col
|
__init__
| null |
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)
|
(self, **kw)
|
27,420
|
sqlobject.col
|
__repr__
| null |
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 + '>'
|
(self)
|
27,421
|
sqlobject.col
|
__set__
| null |
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)
|
(self, obj, value)
|
27,422
|
sqlobject.col
|
_check_case_sensitive
| null |
def _check_case_sensitive(self, db):
if self.char_binary:
raise ValueError("%s does not support "
"binary character columns" % db)
|
(self, db)
|
27,423
|
sqlobject.col
|
_extraSQL
| null |
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
|
(self)
|
27,424
|
sqlobject.col
|
_firebirdType
| null |
def _firebirdType(self):
self._check_case_sensitive("FireBird")
if not self.length:
return 'BLOB SUB_TYPE TEXT'
else:
return self._sqlType()
|
(self)
|
27,425
|
sqlobject.col
|
_get_default
| null |
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
|
(self)
|
27,426
|
sqlobject.col
|
_get_joinName
| null |
def _get_joinName(self):
return self.soClass.sqlmeta.style.instanceIDAttrToAttr(self.name)
|
(self)
|
27,427
|
sqlobject.col
|
_get_validator
| null |
def _get_validator(self):
return self._validator
|
(self)
|
27,428
|
sqlobject.col
|
_maxdbType
| null |
def _maxdbType(self):
self._check_case_sensitive("SAP DB/MaxDB")
if not self.length:
return 'LONG ASCII'
else:
return self._sqlType()
|
(self)
|
27,429
|
sqlobject.col
|
_mssqlType
| null |
def _mssqlType(self):
if self.connection and self.connection.can_use_max_types():
return 'VARBINARY(MAX)'
else:
return "IMAGE"
|
(self)
|
27,430
|
sqlobject.col
|
_mysqlType
| null |
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"
|
(self)
|
27,431
|
sqlobject.col
|
_postgresType
| null |
def _postgresType(self):
return 'BYTEA'
|
(self)
|
27,432
|
sqlobject.col
|
_set_validator
| null |
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
|
(self, value)
|
27,433
|
sqlobject.col
|
_sqlType
| null |
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
|
(self)
|
27,434
|
sqlobject.col
|
_sqliteType
| null |
def _sqliteType(self):
self._check_case_sensitive("SQLite")
return super(SOStringLikeCol, self)._sqliteType()
|
(self)
|
27,435
|
sqlobject.col
|
_sybaseType
| null |
def _sybaseType(self):
self._check_case_sensitive("SYBASE")
type = self._sqlType()
return type
|
(self)
|
27,436
|
sqlobject.col
|
autoConstraints
| null |
def autoConstraints(self):
constraints = [constrs.isString]
if self.length is not None:
constraints += [constrs.MaxLength(self.length)]
return constraints
|
(self)
|
27,437
|
sqlobject.col
|
createSQL
| null |
def createSQL(self):
return ' '.join([self._sqlType()] + self._extraSQL())
|
(self)
|
27,438
|
sqlobject.col
|
createValidators
| null |
def createValidators(self):
return [BinaryValidator(name=self.name)] + \
super(SOBLOBCol, self).createValidators()
|
(self)
|
27,439
|
sqlobject.col
|
firebirdCreateSQL
| null |
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]])
|
(self)
|
27,440
|
sqlobject.col
|
getDbEncoding
| null |
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
|
(self, state, default='utf-8')
|
27,441
|
sqlobject.col
|
maxdbCreateSQL
| null |
def maxdbCreateSQL(self):
return ' '.join([self.dbName, self._maxdbType()] + self._extraSQL())
|
(self)
|
27,442
|
sqlobject.col
|
mssqlCreateSQL
| null |
def mssqlCreateSQL(self, connection=None):
self.connection = connection
return ' '.join([self.dbName, self._mssqlType()] + self._extraSQL())
|
(self, connection=None)
|
27,443
|
sqlobject.col
|
mysqlCreateSQL
| null |
def mysqlCreateSQL(self, connection=None):
self.connection = connection
return ' '.join([self.dbName, self._mysqlType()] + self._extraSQL())
|
(self, connection=None)
|
27,444
|
sqlobject.col
|
postgresCreateSQL
| null |
def postgresCreateSQL(self):
return ' '.join([self.dbName, self._postgresType()] + self._extraSQL())
|
(self)
|
27,445
|
sqlobject.col
|
sqliteCreateSQL
| null |
def sqliteCreateSQL(self):
return ' '.join([self.dbName, self._sqliteType()] + self._extraSQL())
|
(self)
|
27,446
|
sqlobject.col
|
sybaseCreateSQL
| null |
def sybaseCreateSQL(self):
return ' '.join([self.dbName, self._sybaseType()] + self._extraSQL())
|
(self)
|
27,447
|
sqlobject.col
|
SOBigIntCol
| null |
class SOBigIntCol(SOIntCol):
def _sqlType(self):
return self.addSQLAttrs("BIGINT")
|
(**kw)
|
27,450
|
sqlobject.col
|
__init__
| null |
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)
|
(self, **kw)
|
27,454
|
sqlobject.col
|
_firebirdType
| null |
def _firebirdType(self):
return self._sqlType()
|
(self)
|
27,458
|
sqlobject.col
|
_maxdbType
| null |
def _maxdbType(self):
return self._sqlType()
|
(self)
|
27,459
|
sqlobject.col
|
_mssqlType
| null |
def _mssqlType(self):
return self._sqlType()
|
(self)
|
27,460
|
sqlobject.col
|
_mysqlType
| null |
def _mysqlType(self):
return self._sqlType()
|
(self)
|
27,461
|
sqlobject.col
|
_postgresType
| null |
def _postgresType(self):
return self._sqlType()
|
(self)
|
27,463
|
sqlobject.col
|
_sqlType
| null |
def _sqlType(self):
return self.addSQLAttrs("BIGINT")
|
(self)
|
27,464
|
sqlobject.col
|
_sqliteType
| null |
def _sqliteType(self):
# SQLite is naturally typeless, so as a fallback it uses
# no type.
try:
return self._sqlType()
except ValueError:
return ''
|
(self)
|
27,465
|
sqlobject.col
|
_sybaseType
| null |
def _sybaseType(self):
return self._sqlType()
|
(self)
|
27,466
|
sqlobject.col
|
addSQLAttrs
| null |
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 += " UNSIGNED"
if self.zerofill:
_ret += " ZEROFILL"
return _ret
|
(self, str)
|
27,467
|
sqlobject.col
|
autoConstraints
| null |
def autoConstraints(self):
return [constrs.isInt]
|
(self)
|
27,469
|
sqlobject.col
|
createValidators
| null |
def createValidators(self):
return [IntValidator(name=self.name)] + \
super(SOIntCol, self).createValidators()
|
(self)
|
27,478
|
sqlobject.col
|
SOBoolCol
| null |
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"
|
(name, soClass, creationOrder, dbName=None, default=<class 'sqlobject.sqlbuilder.NoDefault'>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class 'sqlobject.sqlbuilder.NoDefault'>, notNone=<class 'sqlobject.sqlbuilder.NoDefault'>, unique=<class 'sqlobject.sqlbuilder.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)
|
27,481
|
sqlobject.col
|
__init__
| null |
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 not isinstance(cascade, (bool, string_type, type(None))):
raise TypeError(
'Expected cascade to be True, False, None or "null", '
"(you gave: %r %r)" % (type(cascade), cascade)
)
if isinstance(cascade, str) and (cascade != 'null'):
raise ValueError(
"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)
|
(self, name, soClass, creationOrder, dbName=None, default=<class 'sqlobject.sqlbuilder.NoDefault'>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class 'sqlobject.sqlbuilder.NoDefault'>, notNone=<class 'sqlobject.sqlbuilder.NoDefault'>, unique=<class 'sqlobject.sqlbuilder.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)
|
27,485
|
sqlobject.col
|
_firebirdType
| null |
def _firebirdType(self):
return 'INT'
|
(self)
|
27,489
|
sqlobject.col
|
_maxdbType
| null |
def _maxdbType(self):
return "BOOLEAN"
|
(self)
|
27,490
|
sqlobject.col
|
_mssqlType
| null |
def _mssqlType(self):
return "BIT"
|
(self)
|
27,491
|
sqlobject.col
|
_mysqlType
| null |
def _mysqlType(self):
return "BOOL"
|
(self)
|
27,492
|
sqlobject.col
|
_postgresType
| null |
def _postgresType(self):
return 'BOOL'
|
(self)
|
27,494
|
sqlobject.col
|
_sqlType
| null |
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
|
(self)
|
27,495
|
sqlobject.col
|
_sqliteType
| null |
def _sqliteType(self):
return "BOOLEAN"
|
(self)
|
27,496
|
sqlobject.col
|
_sybaseType
| null |
def _sybaseType(self):
return "BIT"
|
(self)
|
27,497
|
sqlobject.col
|
autoConstraints
| null |
def autoConstraints(self):
return [constrs.isBool]
|
(self)
|
27,499
|
sqlobject.col
|
createValidators
| null |
def createValidators(self):
return [BoolValidator(name=self.name)] + \
super(SOBoolCol, self).createValidators()
|
(self)
|
27,508
|
sqlobject.col
|
SOCol
| null |
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 not isinstance(cascade, (bool, string_type, type(None))):
raise TypeError(
'Expected cascade to be True, False, None or "null", '
"(you gave: %r %r)" % (type(cascade), cascade)
)
if isinstance(cascade, str) and (cascade != 'null'):
raise ValueError(
"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
|
(name, soClass, creationOrder, dbName=None, default=<class 'sqlobject.sqlbuilder.NoDefault'>, defaultSQL=None, foreignKey=None, alternateID=False, alternateMethodName=None, constraints=None, notNull=<class 'sqlobject.sqlbuilder.NoDefault'>, notNone=<class 'sqlobject.sqlbuilder.NoDefault'>, unique=<class 'sqlobject.sqlbuilder.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)
|
27,527
|
sqlobject.col
|
autoConstraints
| null |
def autoConstraints(self):
return []
|
(self)
|
27,529
|
sqlobject.col
|
createValidators
|
Create a list of validators for the column.
|
def createValidators(self):
"""Create a list of validators for the column."""
return []
|
(self)
|
27,538
|
sqlobject.col
|
SOCurrencyCol
| null |
class SOCurrencyCol(SODecimalCol):
def __init__(self, **kw):
pushKey(kw, 'size', 10)
pushKey(kw, 'precision', 2)
super(SOCurrencyCol, self).__init__(**kw)
|
(**kw)
|
27,541
|
sqlobject.col
|
__init__
| null |
def __init__(self, **kw):
pushKey(kw, 'size', 10)
pushKey(kw, 'precision', 2)
super(SOCurrencyCol, self).__init__(**kw)
|
(self, **kw)
|
27,554
|
sqlobject.col
|
_sqlType
| null |
def _sqlType(self):
return 'DECIMAL(%i, %i)' % (self.size, self.precision)
|
(self)
|
27,559
|
sqlobject.col
|
createValidators
| null |
def createValidators(self):
return [DecimalValidator(name=self.name)] + \
super(SODecimalCol, self).createValidators()
|
(self)
|
27,568
|
sqlobject.col
|
SODateCol
| null |
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
elif default_datetime_implementation == ZOPE_DATETIME_IMPLEMENTATION:
validatorClass = ZopeDateTimeValidator
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'
|
(**kw)
|
27,571
|
sqlobject.col
|
__init__
| null |
def __init__(self, **kw):
dateFormat = kw.pop('dateFormat', None)
if dateFormat:
self.dateFormat = dateFormat
super(SODateCol, self).__init__(**kw)
|
(self, **kw)
|
27,575
|
sqlobject.col
|
_firebirdType
| null |
def _firebirdType(self):
return 'DATE'
|
(self)
|
27,579
|
sqlobject.col
|
_maxdbType
| null |
def _maxdbType(self):
return 'DATE'
|
(self)
|
27,580
|
sqlobject.col
|
_mssqlType
|
SQL Server doesn't have a DATE data type, to emulate we use a vc(10)
|
def _mssqlType(self):
"""
SQL Server doesn't have a DATE data type, to emulate we use a vc(10)
"""
return 'VARCHAR(10)'
|
(self)
|
27,581
|
sqlobject.col
|
_mysqlType
| null |
def _mysqlType(self):
return 'DATE'
|
(self)
|
27,582
|
sqlobject.col
|
_postgresType
| null |
def _postgresType(self):
return 'DATE'
|
(self)
|
27,585
|
sqlobject.col
|
_sqliteType
| null |
def _sqliteType(self):
return 'DATE'
|
(self)
|
27,586
|
sqlobject.col
|
_sybaseType
| null |
def _sybaseType(self):
return self._postgresType()
|
(self)
|
27,589
|
sqlobject.col
|
createValidators
|
Create a validator for the column.
Can be overriden in descendants.
|
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
elif default_datetime_implementation == ZOPE_DATETIME_IMPLEMENTATION:
validatorClass = ZopeDateTimeValidator
if default_datetime_implementation:
_validators.insert(0, validatorClass(name=self.name,
format=self.dateFormat))
return _validators
|
(self)
|
27,598
|
sqlobject.col
|
SODateTimeCol
| null |
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
elif default_datetime_implementation == ZOPE_DATETIME_IMPLEMENTATION:
validatorClass = ZopeDateTimeValidator
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'
|
(**kw)
|
27,601
|
sqlobject.col
|
__init__
| null |
def __init__(self, **kw):
datetimeFormat = kw.pop('datetimeFormat', None)
if datetimeFormat:
self.datetimeFormat = datetimeFormat
super(SODateTimeCol, self).__init__(**kw)
|
(self, **kw)
|
27,605
|
sqlobject.col
|
_firebirdType
| null |
def _firebirdType(self):
return 'TIMESTAMP'
|
(self)
|
27,609
|
sqlobject.col
|
_maxdbType
| null |
def _maxdbType(self):
return 'TIMESTAMP'
|
(self)
|
27,610
|
sqlobject.col
|
_mssqlType
| null |
def _mssqlType(self):
if self.connection and self.connection.can_use_microseconds():
return 'DATETIME2(6)'
else:
return 'DATETIME'
|
(self)
|
27,611
|
sqlobject.col
|
_mysqlType
| null |
def _mysqlType(self):
if self.connection and self.connection.can_use_microseconds():
return 'DATETIME(6)'
else:
return 'DATETIME'
|
(self)
|
27,612
|
sqlobject.col
|
_postgresType
| null |
def _postgresType(self):
return 'TIMESTAMP'
|
(self)
|
27,615
|
sqlobject.col
|
_sqliteType
| null |
def _sqliteType(self):
return 'TIMESTAMP'
|
(self)
|
27,616
|
sqlobject.col
|
_sybaseType
| null |
def _sybaseType(self):
return 'DATETIME'
|
(self)
|
27,619
|
sqlobject.col
|
createValidators
| null |
def createValidators(self):
_validators = super(SODateTimeCol, self).createValidators()
if default_datetime_implementation == DATETIME_IMPLEMENTATION:
validatorClass = DateTimeValidator
elif default_datetime_implementation == MXDATETIME_IMPLEMENTATION:
validatorClass = MXDateTimeValidator
elif default_datetime_implementation == ZOPE_DATETIME_IMPLEMENTATION:
validatorClass = ZopeDateTimeValidator
if default_datetime_implementation:
_validators.insert(0, validatorClass(name=self.name,
format=self.datetimeFormat))
return _validators
|
(self)
|
27,628
|
sqlobject.col
|
SODecimalCol
| null |
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()
|
(**kw)
|
27,631
|
sqlobject.col
|
__init__
| null |
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)
|
(self, **kw)
|
27,658
|
sqlobject.col
|
SODecimalStringCol
| null |
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)
|
(**kw)
|
27,661
|
sqlobject.col
|
__init__
| null |
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)
|
(self, **kw)
|
27,671
|
sqlobject.col
|
_mssqlType
| null |
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
return type
|
(self)
|
27,672
|
sqlobject.col
|
_mysqlType
| null |
def _mysqlType(self):
type = self._sqlType()
if self.char_binary:
type += " BINARY"
return type
|
(self)
|
27,673
|
sqlobject.col
|
_postgresType
| null |
def _postgresType(self):
self._check_case_sensitive("PostgreSQL")
return super(SOStringLikeCol, self)._postgresType()
|
(self)
|
27,680
|
sqlobject.col
|
createValidators
| null |
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)
|
(self)
|
27,689
|
sqlobject.col
|
SOEnumCol
| null |
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)
|
(**kw)
|
27,692
|
sqlobject.col
|
__init__
| null |
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)
|
(self, **kw)
|
27,696
|
sqlobject.col
|
_firebirdType
| null |
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
|
(self)
|
27,700
|
sqlobject.col
|
_getlength
|
None counts as 0; everything else uses len()
|
def _getlength(self, obj):
"""
None counts as 0; everything else uses len()
"""
if obj is None:
return 0
else:
return len(obj)
|
(self, obj)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.