def __init__(self, dsn=None, host=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
# Register a converter for psycopg Binary type.
registerConverter(type(psycopg.Binary('')),
PsycoBinaryConverter)
if dsn is None:
dsn = []
if db:
dsn.append('dbname=%s' % db)
if user:
dsn.append('user=%s' % user)
if passwd:
dsn.append('password=%s' % passwd)
if host:
# @@: right format?
dsn.append('host=%s' % host)
dsn = ' '.join(dsn)
self.dsn = dsn
DBAPI.__init__(self, **kw)
# Server version cache
self._server_version = None # Not yet initialized
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:
autoCommmit = int(autoCommit)
else:
autoCommit = None
kw['autoCommit'] = autoCommit
DBAPI.__init__(self, **kw)
def __init__(self, db, user, password='', host='localhost',
locking=1, **kw):
db = db.strip('/')
global Sybase
if Sybase is None:
import Sybase
Sybase._ctx.debug = 0
from Sybase import NumericType
from sqlobject.converters import registerConverter, IntConverter
registerConverter(NumericType, IntConverter)
self.module = Sybase
self.locking = int(locking)
self.host = host
self.db = db
self.user = user
self.password = password
autoCommit = kw.get('autoCommit')
if autoCommit:
autoCommmit = int(autoCommit)
else:
autoCommit = None
kw['autoCommit'] = autoCommit
DBAPI.__init__(self, **kw)
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
self.module = psycopg
elif driver == 'psycopg1':
import psycopg
self.module = psycopg
elif driver == 'psycopg':
try:
import psycopg2 as psycopg
except ImportError:
import psycopg
self.module = psycopg
elif driver == 'pygresql':
import pgdb
self.module = pgdb
elif driver in ('py-postgresql', 'pypostgresql'):
from postgresql.driver import dbapi20
self.module = dbapi20
elif driver == 'pyodbc':
import pyodbc
self.module = pyodbc
elif driver == 'pypyodbc':
import pypyodbc
self.module = pypyodbc
elif driver == 'odbc':
try:
import pyodbc
except ImportError:
import pypyodbc as pyodbc
self.module = pyodbc
else:
raise ValueError(
'Unknown PostgreSQL driver "%s", '
'expected psycopg, psycopg2, psycopg1, '
'pygresql, pypostgresql, '
'odbc, pyodbc or pypyodbc' % driver)
except ImportError:
pass
else:
break
else:
raise ImportError(
'Cannot find a PostgreSQL driver, tried %s' % drivers)
if driver.startswith('psycopg'):
# Register a converter for psycopg Binary type.
registerConverter(type(self.module.Binary('')),
PsycoBinaryConverter)
elif type(self.module.Binary) in (type, type(PostgresBinaryConverter)):
# Register a converter for Binary type.
registerConverter(type(self.module.Binary(b'')),
PostgresBinaryConverter)
self.db = db
self.user = user
self.password = password
self.host = host
self.port = port
if driver in ('odbc', 'pyodbc', 'pypyodbc'):
self.make_odbc_conn_str(kw.pop('odbcdrv', 'PostgreSQL ANSI'),
db, host, port, user, password
)
sslmode = kw.pop("sslmode", None)
if sslmode:
self.odbc_conn_str += ';sslmode=require'
else:
self.dsn_dict = dsn_dict = {}
if host:
dsn_dict["host"] = host
if port:
if driver == 'pygresql':
dsn_dict["host"] = "%s:%d" % (host, port)
elif driver.startswith('psycopg') and \
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)
if driver in ('py-postgresql', 'pypostgresql'):
if host and host.startswith('/'):
dsn_dict["host"] = dsn_dict["port"] = None
dsn_dict["unix"] = host
else:
if "unix" in dsn_dict:
del dsn_dict["unix"]
self.dsn = dsn
self.driver = driver
self.unicodeCols = kw.pop('unicodeCols', False)
self.schema = kw.pop('schema', None)
self.dbEncoding = kw.pop("charset", None)
DBAPI.__init__(self, **kw)
def __init__(self, dsn=None, host=None, port=None, db=None,
user=None, password=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:
try:
import psycopg2 as psycopg
except ImportError:
import 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 usePygresql:
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
self.use_dsn = dsn is not None
if dsn is None:
if usePygresql:
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)
dsn = ' '.join(dsn)
self.dsn = dsn
self.unicodeCols = kw.pop('unicodeCols', False)
self.schema = kw.pop('schema', None)
DBAPI.__init__(self, **kw)
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)
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)
from sqlobject.sqlbuilder import SQLExpression, SQLObjectField, \
Select, Insert, Update, Delete, Replace, \
SQLTrueClauseClass, SQLConstant, SQLPrefix, SQLCall, SQLOp, \
_LikeQuoted
class SOTestClass:
def __repr__(self):
return '<SOTestClass>'
def SOTestClassConverter(value, db):
return repr(value)
registerConverter(SOTestClass, SOTestClassConverter)
class NewSOTestClass:
__metaclass__ = type
def __repr__(self):
return '<NewSOTestClass>'
def NewSOTestClassConverter(value, db):
return repr(value)
registerConverter(NewSOTestClass, NewSOTestClassConverter)
from sqlobject.sqlbuilder import SQLExpression, SQLObjectField, \
Select, Insert, Update, Delete, Replace, \
SQLTrueClauseClass, SQLConstant, SQLPrefix, SQLCall, SQLOp, \
_LikeQuoted
class SOTestClass:
def __repr__(self):
return '<SOTestClass>'
def SOTestClassConverter(value, db):
return repr(value)
registerConverter(SOTestClass, SOTestClassConverter)
class NewSOTestClass:
__metaclass__ = type
def __repr__(self):
return '<NewSOTestClass>'
def NewSOTestClassConverter(value, db):
return repr(value)
registerConverter(NewSOTestClass, NewSOTestClassConverter)
def __init__(self, dsn=None, host=None, port=None, db=None,
user=None, passwd=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:
import 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 = passwd
self.dsn_dict = dsn_dict = {}
if host:
dsn_dict["host"] = host
if port:
if usePygresql:
dsn_dict["host"] = "%s:%d" % (host, port)
else:
dsn_dict["port"] = str(port)
if db:
dsn_dict["database"] = db
if user:
dsn_dict["user"] = user
if passwd:
dsn_dict["password"] = passwd
self.use_dsn = dsn is not None
if dsn is None:
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)
if port:
dsn.append('port=%d' % port)
dsn = ' '.join(dsn)
self.dsn = dsn
self.unicodeCols = unicodeCols
DBAPI.__init__(self, **kw)
# Server version cache
self._server_version = None # Not yet initialized
from sqlobject.sqlbuilder import sqlrepr
from sqlobject.sqlbuilder import SQLExpression, SQLObjectField, \
Select, Insert, Update, Delete, Replace, \
SQLTrueClauseClass, SQLConstant, SQLPrefix, SQLCall, SQLOp
from sqlobject.converters import registerConverter
class TestClass:
def __repr__(self):
return '<TestClass>'
def TestClassConverter(value, db):
return repr(value)
registerConverter(TestClass, TestClassConverter)
class NewTestClass:
__metaclass__ = type
def __repr__(self):
return '<NewTestClass>'
def NewTestClassConverter(value, db):
return repr(value)
registerConverter(NewTestClass, NewTestClassConverter)
def _sqlrepr(self, db):
return '<%s>' % self.__class__.__name__
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 in ('psycopg', 'psycopg2'):
import psycopg2 as psycopg
self.module = psycopg
elif driver == 'pygresql':
import pgdb
self.module = pgdb
elif driver in ('py-postgresql', 'pypostgresql'):
from postgresql.driver import dbapi20
self.module = dbapi20
elif driver == 'pg8000':
import pg8000
self.module = pg8000
elif driver == 'pyodbc':
import pyodbc
self.module = pyodbc
elif driver == 'pypyodbc':
import pypyodbc
self.module = pypyodbc
elif driver == 'odbc':
try:
import pyodbc
except ImportError:
import pypyodbc as pyodbc
self.module = pyodbc
else:
raise ValueError(
'Unknown PostgreSQL driver "%s", '
'expected psycopg, psycopg2, '
'pygresql, pypostgresql, pg8000, '
'odbc, pyodbc or pypyodbc' % driver)
except ImportError:
pass
else:
break
else:
raise ImportError(
'Cannot find a PostgreSQL driver, tried %s' % drivers)
if driver.startswith('psycopg'):
# Register a converter for psycopg Binary type.
registerConverter(type(self.module.Binary('')),
PsycoBinaryConverter)
elif driver in ('pygresql', 'py-postgresql', 'pypostgresql', 'pg8000'):
registerConverter(type(self.module.Binary(b'')),
PostgresBinaryConverter)
elif driver in ('odbc', 'pyodbc', 'pypyodbc'):
registerConverter(bytearray, OdbcBinaryConverter)
self.db = db
self.user = user
self.password = password
self.host = host
self.port = port
if driver in ('odbc', 'pyodbc', 'pypyodbc'):
self.make_odbc_conn_str(kw.pop('odbcdrv', 'PostgreSQL ANSI'),
db, host, port, user, password
)
sslmode = kw.pop("sslmode", None)
if sslmode:
self.odbc_conn_str += ';sslmode=require'
else:
self.dsn_dict = dsn_dict = {}
if host:
dsn_dict["host"] = host
if port:
if driver == 'pygresql':
dsn_dict["host"] = "%s:%d" % (host, port)
elif driver.startswith('psycopg') and \
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)
if driver in ('py-postgresql', 'pypostgresql'):
if host and host.startswith('/'):
dsn_dict["host"] = dsn_dict["port"] = None
dsn_dict["unix"] = host
else:
if "unix" in dsn_dict:
del dsn_dict["unix"]
if driver == 'pg8000':
if host and host.startswith('/'):
dsn_dict["host"] = None
dsn_dict["unix_sock"] = host
if user is None:
dsn_dict["user"] = getuser()
self.dsn = dsn
self.driver = driver
self.unicodeCols = kw.pop('unicodeCols', False)
self.schema = kw.pop('schema', None)
self.dbEncoding = kw.pop("charset", None)
DBAPI.__init__(self, **kw)
from sqlobject.sqlbuilder import SQLExpression, SQLObjectField, \
Select, Insert, Update, Delete, Replace, \
SQLTrueClauseClass, SQLConstant, SQLPrefix, SQLCall, SQLOp, \
_LikeQuoted
class TestClass:
def __repr__(self):
return '<TestClass>'
def TestClassConverter(value, db):
return repr(value)
registerConverter(TestClass, TestClassConverter)
class NewTestClass:
__metaclass__ = type
def __repr__(self):
return '<NewTestClass>'
def NewTestClassConverter(value, db):
return repr(value)
registerConverter(NewTestClass, NewTestClassConverter)
