def __init__(self, sequence=None):
# Note that as immutable objects, tuples are created with __new__,
# so we must not pass the argument to the __init__ method of tuple.
super(dDataSet, self).__init__()
self._connection = None
self._cursor = None
self._bizobj = None
self._populated = False
self._typeStructure = {}
# We may need to encode fields that are not legal names.
self.fieldAliases = {}
# Keep a hash value to tell if we need to re-populate
self._dataHash = ""
sqlite.register_adapter(Decimal, self._adapt_decimal)
# When filtering datasets, we need a reference to the dataset
# this dataset was derived from.
self._sourceDataSet = None
# Register the converters
sqlite.register_converter("decimal", self._convert_decimal)
self._typeDict = {int: "integer", int: "integer", str: "text",
str: "text", float: "real", datetime.date: "date",
datetime.datetime: "timestamp", Decimal: "decimal"}
def __init__(self, sequence=None):
# Note that as immutable objects, tuples are created with __new__,
# so we must not pass the argument to the __init__ method of tuple.
super(dDataSet, self).__init__()
self._connection = None
self._cursor = None
self._bizobj = None
self._populated = False
self._typeStructure = {}
# We may need to encode fields that are not legal names.
self.fieldAliases = {}
# Keep a hash value to tell if we need to re-populate
self._dataHash = ""
sqlite.register_adapter(Decimal, self._adapt_decimal)
# When filtering datasets, we need a reference to the dataset
# this dataset was derived from.
self._sourceDataSet = None
# Register the converters
sqlite.register_converter("decimal", self._convert_decimal)
self._typeDict = {
int: "integer",
long: "integer",
str: "text",
unicode: "text",
float: "real",
datetime.date: "date",
datetime.datetime: "timestamp",
Decimal: "decimal"
}
def setUp(self):
self.con = sqlite.connect(":memory:")
try:
del sqlite.adapters[int]
except:
pass
sqlite.register_adapter(int, ObjectAdaptationTests.cast)
self.cur = self.con.cursor()
def setUp(self):
self.con = sqlite.connect(":memory:")
try:
del sqlite.adapters[int]
except:
pass
sqlite.register_adapter(int, ObjectAdaptationTests.cast)
self.cur = self.con.cursor()
def __init__(self):
self.needinit = 0
self.dbpath = "%s/.pimpdb" % os.getenv("HOME")
self.streamlist = {}
sqlite.register_adapter(str, adapt_string)
sqlite.register_converter('VARCHAR', decode_string)
if not os.path.isfile(self.dbpath):
print "Need to create db"
self.needinit = 1
# Initialize the db if we need to.
if self.needinit:
self.db = sqlite.connect(self.dbpath, detect_types=sqlite.PARSE_DECLTYPES)
self.initdb()
self.findmusic()
self.db.close()
self.queue = Queue.Queue()
MusicDB.instance = self
Thread.__init__(self,name="MusicDB")
def _getConnectParams_ (self, connectData):
from pysqlite2 import dbapi2
# Register the missing converter and adapater for time values
dbapi2.register_adapter (datetime.time, adapt_time)
dbapi2.register_converter ('time', convert_time)
# Register the missing converter and adapter for boolean values
dbapi2.register_adapter (bool, adapt_boolean)
dbapi2.register_converter ('boolean', convert_boolean)
# NOTE: gnue-forms allways creates datetime values, even for dates. This is
# why we have to define our own converter. Please remove as soon as
# gnue-forms is fixed.
dbapi2.register_converter ('date', convert_date)
# mandatory parameters
kwargs = {'database' : connectData ['dbname'],
'detect_types': dbapi2.PARSE_DECLTYPES}
if 'timeout' in connectData:
kwargs ['timeout'] = connectData ['timeout']
return ([], kwargs)
def getConn(self):
def dict_factory(cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
def boolAdapter(b):
if b:
return 'True'
else:
return 'False'
# Return connection for current thread
id = threading.currentThread().getName()
if not id in self.conns:
sqlite.register_adapter(bool, boolAdapter)
conn = sqlite.connect(self.name, timeout=30, isolation_level = None)
conn.row_factory = dict_factory
self.connParams[id] = "?"
self.conns[id] = conn
return self.conns[id]
def getConn(self):
def dict_factory(cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
def boolAdapter(b):
if b:
return 'True'
else:
return 'False'
# Return connection for current thread
id = threading.currentThread().getName()
if not id in self.conns:
sqlite.register_adapter(bool, boolAdapter)
conn = sqlite.connect(self.name, timeout=30, isolation_level=None)
conn.row_factory = dict_factory
self.connParams[id] = "?"
self.conns[id] = conn
return self.conns[id]
return self.cursor.fetchone()[0]
def lock(self, table):
pass
def has_constraint(self):
return False
def limit_clause(self, select, limit=None, offset=None):
if limit is not None:
select += ' LIMIT %d' % limit
if offset is not None:
if limit is None:
select += ' LIMIT -1'
select += ' OFFSET %d' % offset
return select
sqlite.register_converter('NUMERIC', lambda val: Decimal(val))
if sys.version_info[0] == 2:
sqlite.register_adapter(Decimal, lambda val: buffer(str(val)))
else:
sqlite.register_adapter(Decimal, lambda val: bytes(str(val)))
def adapt_datetime(val):
return val.replace(tzinfo=None).isoformat(" ")
sqlite.register_adapter(datetime.datetime, adapt_datetime)
sqlite.register_adapter(datetime.time, lambda val: val.isoformat())
sqlite.register_converter('TIME', lambda val: datetime.time(*map(int,
val.split(':'))))
import os, sha
from twisted.python.filepath import FilePath
from twisted.trial import unittest
assert sqlite.version_info >= (2, 1)
class DBExcept(Exception):
"""An error occurred in accessing the database."""
pass
class khash(str):
"""Dummy class to convert all hashes to base64 for storing in the DB."""
# Initialize the database to work with 'khash' objects (binary strings)
sqlite.register_adapter(khash, b2a_base64)
sqlite.register_converter("KHASH", a2b_base64)
sqlite.register_converter("khash", a2b_base64)
sqlite.enable_callback_tracebacks(True)
class DB:
"""An sqlite database for storing persistent files and hashes.
@type db: L{twisted.python.filepath.FilePath}
@ivar db: the database file to use
@type conn: L{pysqlite2.dbapi2.Connection}
@ivar conn: an open connection to the sqlite database
"""
def __init__(self, db):
"""Load or create the database file.
def decoder(conv_func):
""" The Python sqlite3 interface returns always byte strings.
This function converts the received value to a regular string before
passing it to the receiver function.
"""
return lambda s: conv_func(s.decode('utf-8'))
Database.register_converter(str("bool"), decoder(lambda s: s == '1'))
Database.register_converter(str("time"), decoder(parse_time))
Database.register_converter(str("date"), decoder(parse_date))
Database.register_converter(str("datetime"), decoder(parse_datetime))
Database.register_converter(str("timestamp"), decoder(parse_datetime))
Database.register_converter(str("TIMESTAMP"), decoder(parse_datetime))
Database.register_converter(str("decimal"), decoder(backend_utils.typecast_decimal))
Database.register_adapter(datetime.datetime, adapt_datetime_warn_on_aware_datetime)
Database.register_adapter(decimal.Decimal, backend_utils.rev_typecast_decimal)
if six.PY2:
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeBytes, lambda s: s.decode('utf-8'))
class DatabaseWrapper(BaseDatabaseWrapper):
vendor = 'sqlite'
# SQLite doesn't actually support most of these types, but it "does the right
# thing" given more verbose field definitions, so leave them as is so that
# schema inspection is more useful.
data_types = {
'AutoField': 'integer',
'BigAutoField': 'integer',
'BinaryField': 'BLOB',
exc = e1
else:
module = 'either pysqlite2 or sqlite3 modules (tried in that order)'
raise ImproperlyConfigured("Error loading %s: %s" % (module, exc))
DatabaseError = Database.DatabaseError
IntegrityError = Database.IntegrityError
Database.register_converter("bool", lambda s: str(s) == '1')
Database.register_converter("time", util.typecast_time)
Database.register_converter("date", util.typecast_date)
Database.register_converter("datetime", util.typecast_timestamp)
Database.register_converter("timestamp", util.typecast_timestamp)
Database.register_converter("TIMESTAMP", util.typecast_timestamp)
Database.register_converter("decimal", util.typecast_decimal)
Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
if Database.version_info >= (2, 4, 1):
# Starting in 2.4.1, the str type is not accepted anymore, therefore,
# we convert all str objects to Unicode
# As registering a adapter for a primitive type causes a small
# slow-down, this adapter is only registered for sqlite3 versions
# needing it.
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeString, lambda s: s.decode('utf-8'))
class DatabaseFeatures(BaseDatabaseFeatures):
# SQLite cannot handle us only partially reading from a cursor's result set
# and then writing the same rows to the database in another cursor. This
# setting ensures we always read result sets fully into memory all in one
# go.
#SQLite expects a string
if boolfrompython:
return '1'
else:
return '0'
def converter4bool(strfromdb):
#SQLite returns a string
if strfromdb == '1':
return True
else:
return False
sqlite.register_adapter(bool, adapter4bool)
sqlite.register_converter('BOOLEAN', converter4bool)
def connect(database):
con = sqlite.connect(database,
factory=BotsConnection,
detect_types=sqlite.PARSE_DECLTYPES,
timeout=99.0,
isolation_level='IMMEDIATE')
con.row_factory = sqlite.Row
con.execute('''PRAGMA synchronous=OFF''')
return con
class BotsConnection(sqlite.Connection):
"""
return lambda s: conv_func(s.decode('utf-8'))
Database.register_converter(str("bool"), decoder(lambda s: s == '1'))
Database.register_converter(str("time"), decoder(parse_time))
Database.register_converter(str("date"), decoder(parse_date))
Database.register_converter(str("datetime"),
decoder(parse_datetime_with_timezone_support))
Database.register_converter(str("timestamp"),
decoder(parse_datetime_with_timezone_support))
Database.register_converter(str("TIMESTAMP"),
decoder(parse_datetime_with_timezone_support))
Database.register_converter(str("decimal"), decoder(util.typecast_decimal))
Database.register_adapter(datetime.datetime,
adapt_datetime_with_timezone_support)
Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
if Database.version_info >= (2, 4, 1):
# Starting in 2.4.1, the str type is not accepted anymore, therefore,
# we convert all str objects to Unicode
# As registering a adapter for a primitive type causes a small
# slow-down, this adapter is only registered for sqlite3 versions
# needing it (Python 2.6 and up).
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeBytes, lambda s: s.decode('utf-8'))
class DatabaseFeatures(BaseDatabaseFeatures):
# SQLite cannot handle us only partially reading from a cursor's result set
# and then writing the same rows to the database in another cursor. This
# setting ensures we always read result sets fully into memory all in one
config.PATH_DATABASE, detect_types=sqlite3.PARSE_DECLTYPES
) # allows storing datetime, etc.
conn.row_factory = sqlite3.Row
return conn
def close_connection_if_open():
"""
Close the connection to the database, if any.
"""
try:
conn = flask.g._database_connection
except AttributeError:
pass
else:
conn.close()
del flask.g._database_connection
# Allow storing tuple, dict, or bool directly in the database
sqlite3.register_adapter(tuple, repr)
sqlite3.register_converter(str("tuple"), ast.literal_eval)
sqlite3.register_adapter(dict, repr)
sqlite3.register_converter(str("dict"), ast.literal_eval)
sqlite3.register_adapter(bool, lambda b: {True: 1, False: 0, None: None}[b])
sqlite3.register_converter(str("boolean"), lambda s: {
1: True,
0: False,
None: None
}[s])
def __init__(self,
connection_string="",
mod_spatialite_path="mod_spatialite",
table_prefix=""):
dbapi2.register_converter("BOOLEAN", lambda x: bool(int(x)))
dbapi2.register_adapter(bool, lambda x: int(x))
dbapi2.register_converter("UUID", lambda x: uuid.UUID(x.decode()))
dbapi2.register_adapter(uuid.UUID, lambda x: x.hex)
dbapi2.register_converter("GEOMETRY", _cast_geometry)
dbapi2.register_adapter(geometry.Point, _adapt_geometry)
dbapi2.register_adapter(geometry.LineString, _adapt_geometry)
dbapi2.register_adapter(geometry.Polygon, _adapt_geometry)
dbapi2.register_adapter(geometry.MultiPoint, _adapt_geometry)
dbapi2.register_adapter(geometry.MultiLineString, _adapt_geometry)
dbapi2.register_adapter(geometry.MultiPolygon, _adapt_geometry)
self._connection_string = connection_string
self._connection = SQLiteConnection(connection_string,
mod_spatialite_path, self)
if table_prefix and not re.match("[a-z][_a-z]*(\.[a-z][_a-z]*)*",
table_prefix):
raise ValueError("invalid table_prefix %s" % table_prefix)
self._table_prefix = table_prefix
self._core_table_name = self._table_name("core")
self._link_table_name = self._table_name("link")
self._tag_table_name = self._table_name("tag")
self._namespace_schemas = {}
self._sql_builder = sql.SQLBuilder({}, sql.TypeMap(), {},
self._table_name, self._placeholder,
self._placeholder,
self._rewriter_property)
from pysqlite2 import dbapi2 as sqlite
import datetime, time
def adapt_datetime(ts):
return time.mktime(ts.timetuple())
sqlite.register_adapter(datetime.datetime, adapt_datetime)
con = sqlite.connect(":memory:")
cur = con.cursor()
now = datetime.datetime.now()
cur.execute("select ?", (now,))
print cur.fetchone()[0]
import re
try:
from hashlib import md5
except ImportError:
from md5 import md5
try:
from pysqlite2 import dbapi2 as sqlite # ... all development was with pysqlite2
except ImportError:
from sqlite3 import dbapi2 as sqlite # I hope we are compatible with sqlite3
import numpy
from sqlutil import adapt_numpyarray, convert_numpyarray,\
adapt_object, convert_object
from rest_table import Table2array
from convert import irecarray_to_py
sqlite.register_adapter(numpy.ndarray,adapt_numpyarray)
sqlite.register_adapter(numpy.recarray,adapt_numpyarray)
sqlite.register_adapter(numpy.core.records.recarray,adapt_numpyarray)
sqlite.register_adapter(tuple,adapt_object)
sqlite.register_adapter(list,adapt_object)
sqlite.register_converter("NumpyArray", convert_numpyarray)
sqlite.register_converter("Object", convert_object)
class SQLarray(object):
"""A SQL table that returns (mostly) rec arrays.
.. method:: SQLarray([name[,records[,columns[,cachesize=5,connection=None,dbfile=":memory:"]]]])
:Arguments:
*name*
from time import sleep
import os
from twisted.trial import unittest
class DBExcept(Exception):
pass
class khash(str):
"""Dummy class to convert all hashes to base64 for storing in the DB."""
class dht_value(str):
"""Dummy class to convert all DHT values to base64 for storing in the DB."""
# Initialize the database to work with 'khash' objects (binary strings)
sqlite.register_adapter(khash, b2a_base64)
sqlite.register_converter("KHASH", a2b_base64)
sqlite.register_converter("khash", a2b_base64)
# Initialize the database to work with DHT values (binary strings)
sqlite.register_adapter(dht_value, b2a_base64)
sqlite.register_converter("DHT_VALUE", a2b_base64)
sqlite.register_converter("dht_value", a2b_base64)
class DB:
"""An sqlite database for storing persistent node info and key/value pairs.
@type db: C{string}
@ivar db: the database file to use
@type conn: L{pysqlite2.dbapi2.Connection}
@ivar conn: an open connection to the sqlite database
import re
try:
from hashlib import md5
except ImportError:
from md5 import md5
try:
from pysqlite2 import dbapi2 as sqlite # ... all development was with pysqlite2
except ImportError:
from sqlite3 import dbapi2 as sqlite # I hope we are compatible with sqlite3
import numpy
from sqlutil import adapt_numpyarray, convert_numpyarray,\
adapt_object, convert_object
from rest_table import Table2array
from convert import irecarray_to_py
sqlite.register_adapter(numpy.ndarray, adapt_numpyarray)
sqlite.register_adapter(numpy.recarray, adapt_numpyarray)
sqlite.register_adapter(numpy.core.records.recarray, adapt_numpyarray)
sqlite.register_adapter(tuple, adapt_object)
sqlite.register_adapter(list, adapt_object)
sqlite.register_converter("NumpyArray", convert_numpyarray)
sqlite.register_converter("Object", convert_object)
class SQLarray(object):
"""A SQL table that returns (mostly) rec arrays.
.. method:: SQLarray([name[,records[,columns[,cachesize=5,connection=None,dbfile=":memory:"]]]])
:Arguments:
*name*
This function converts the received value to a regular string before
passing it to the receiver function.
"""
return lambda s: conv_func(s.decode('utf-8'))
Database.register_converter(str("bool"), decoder(lambda s: s == '1'))
Database.register_converter(str("time"), decoder(parse_time))
Database.register_converter(str("date"), decoder(parse_date))
Database.register_converter(str("datetime"), decoder(parse_datetime))
Database.register_converter(str("timestamp"), decoder(parse_datetime))
Database.register_converter(str("TIMESTAMP"), decoder(parse_datetime))
Database.register_converter(str("decimal"),
decoder(backend_utils.typecast_decimal))
Database.register_adapter(decimal.Decimal, backend_utils.rev_typecast_decimal)
if six.PY2:
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeBytes, lambda s: s.decode('utf-8'))
class DatabaseWrapper(BaseDatabaseWrapper):
vendor = 'sqlite'
# SQLite doesn't actually support most of these types, but it "does the right
# thing" given more verbose field definitions, so leave them as is so that
# schema inspection is more useful.
data_types = {
'AutoField': 'integer',
'BigAutoField': 'integer',
'BinaryField': 'BLOB',
'BooleanField': 'bool',
""" The Python sqlite3 interface returns always byte strings.
This function converts the received value to a regular string before
passing it to the receiver function.
"""
return lambda s: conv_func(s.decode('utf-8'))
Database.register_converter("bool", decoder(lambda s: s == '1'))
Database.register_converter("time", decoder(parse_time))
Database.register_converter("date", decoder(parse_date))
Database.register_converter("datetime", decoder(parse_datetime))
Database.register_converter("timestamp", decoder(parse_datetime))
Database.register_converter("TIMESTAMP", decoder(parse_datetime))
Database.register_converter("decimal", decoder(backend_utils.typecast_decimal))
Database.register_adapter(decimal.Decimal, backend_utils.rev_typecast_decimal)
class DatabaseWrapper(BaseDatabaseWrapper):
vendor = 'sqlite'
# SQLite doesn't actually support most of these types, but it "does the right
# thing" given more verbose field definitions, so leave them as is so that
# schema inspection is more useful.
data_types = {
'AutoField': 'integer',
'BigAutoField': 'integer',
'BinaryField': 'BLOB',
'BooleanField': 'bool',
'CharField': 'varchar(%(max_length)s)',
'DateField': 'date',
'DateTimeField': 'datetime',
import datetime
import decimal
from playhouse.sqlite_ext import *
# Peewee assumes that the `pysqlite2` module was compiled against the
# BerkeleyDB SQLite libraries.
from pysqlite2 import dbapi2 as berkeleydb
berkeleydb.register_adapter(decimal.Decimal, str)
berkeleydb.register_adapter(datetime.date, str)
berkeleydb.register_adapter(datetime.time, str)
class BerkeleyDatabase(SqliteExtDatabase):
def _connect(self, database, **kwargs):
conn = berkeleydb.connect(database, **kwargs)
self._add_conn_hooks(conn)
return conn
from twisted.trial import unittest
assert sqlite.version_info >= (2, 1)
class DBExcept(Exception):
"""An error occurred in accessing the database."""
pass
class khash(str):
"""Dummy class to convert all hashes to base64 for storing in the DB."""
# Initialize the database to work with 'khash' objects (binary strings)
sqlite.register_adapter(khash, b2a_base64)
sqlite.register_converter("KHASH", a2b_base64)
sqlite.register_converter("khash", a2b_base64)
sqlite.enable_callback_tracebacks(True)
class DB:
"""An sqlite database for storing persistent files and hashes.
@type db: L{twisted.python.filepath.FilePath}
@ivar db: the database file to use
@type conn: L{pysqlite2.dbapi2.Connection}
@ivar conn: an open connection to the sqlite database
"""
def __init__(self, db):
"""Load or create the database file.
import u
# FIXME: Not sure exactly where this searches...
SPATIALITE_PATH = 'libspatialite.so'
### Geometry adapters ###
# FIXME: These do string/geometry converstion, but that's not enough: also
# need to make function calls. See above.
def geometry_adapt(g):
return g.wkt # FIXME: change to EWKT when SpatiaLite supports it
sqlite3.register_adapter(geos.Point, geometry_adapt)
def geometry_convert(ewkt):
return geos.GEOSGeometry(ewkt)
sqlite3.register_converter('geom', geometry_convert)
sqlite3.register_converter('geometry', geometry_convert)
### Other adapters ###
def datetime_convert(s):
# FIXME: This is here because the built-in datetime adapter is too stupid
# to parse timestamps with a time zone. Remove when brain damage is gone.
else:
module = 'either pysqlite2 or sqlite3 modules (tried in that order)'
raise ImproperlyConfigured("Error loading %s: %s" % (module, exc))
DatabaseError = Database.DatabaseError
IntegrityError = Database.IntegrityError
Database.register_converter("bool", lambda s: str(s) == '1')
Database.register_converter("time", util.typecast_time)
Database.register_converter("date", util.typecast_date)
Database.register_converter("datetime", util.typecast_timestamp)
Database.register_converter("timestamp", util.typecast_timestamp)
Database.register_converter("TIMESTAMP", util.typecast_timestamp)
Database.register_converter("decimal", util.typecast_decimal)
Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
if Database.version_info >= (2,4,1):
# Starting in 2.4.1, the str type is not accepted anymore, therefore,
# we convert all str objects to Unicode
# As registering a adapter for a primitive type causes a small
# slow-down, this adapter is only registered for sqlite3 versions
# needing it.
Database.register_adapter(str, lambda s:s.decode('utf-8'))
Database.register_adapter(SafeString, lambda s:s.decode('utf-8'))
class DatabaseFeatures(BaseDatabaseFeatures):
# SQLite cannot handle us only partially reading from a cursor's result set
# and then writing the same rows to the database in another cursor. This
# setting ensures we always read result sets fully into memory all in one
# go.
can_use_chunked_reads = False
from pysqlite2 import dbapi2 as sqlite3
class Point(object):
def __init__(self, x, y):
self.x, self.y = x, y
def adapt_point(point):
return "%f;%f" % (point.x, point.y)
sqlite3.register_adapter(Point, adapt_point)
con = sqlite3.connect(":memory:")
cur = con.cursor()
p = Point(4.0, -3.2)
cur.execute("select ?", (p,))
print cur.fetchone()[0]
def decoder(conv_func):
""" The Python sqlite3 interface returns always byte strings.
This function converts the received value to a regular string before
passing it to the receiver function.
"""
return lambda s: conv_func(s.decode('utf-8'))
Database.register_converter(str("bool"), decoder(lambda s: s == '1'))
Database.register_converter(str("time"), decoder(parse_time))
Database.register_converter(str("date"), decoder(parse_date))
Database.register_converter(str("datetime"), decoder(parse_datetime))
Database.register_converter(str("timestamp"), decoder(parse_datetime))
Database.register_converter(str("TIMESTAMP"), decoder(parse_datetime))
Database.register_converter(str("decimal"), decoder(backend_utils.typecast_decimal))
Database.register_adapter(datetime.datetime, adapt_datetime_warn_on_aware_datetime)
Database.register_adapter(decimal.Decimal, backend_utils.rev_typecast_decimal)
if six.PY2:
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeBytes, lambda s: s.decode('utf-8'))
class DatabaseWrapper(BaseDatabaseWrapper):
vendor = 'sqlite'
# SQLite doesn't actually support most of these types, but it "does the right
# thing" given more verbose field definitions, so leave them as is so that
# schema inspection is more useful.
data_types = {
'AutoField': 'integer',
'BinaryField': 'BLOB',
'BooleanField': 'bool',
import re
reformatparamstyle = re.compile(u'%\((?P<name>[^)]+)\)s')
#~ #bots engine uses:
#~ ''' SELECT *
#~ FROM ta
#~ WHERE idta=%(idta)s ''',
#~ {'idta':12345})
#~ #SQLite wants:
#~ ''' SELECT *
#~ FROM ta
#~ WHERE idta=:idta ''',
#~ {'idta': 12345}
sqlite.register_adapter(bool, lambda s: '1' if s else '0')
sqlite.register_converter('BOOLEAN', lambda s: s == '1')
def connect(database):
con = sqlite.connect(database,
factory=BotsConnection,
detect_types=sqlite.PARSE_DECLTYPES,
timeout=99.0,
isolation_level='EXCLUSIVE')
con.row_factory = sqlite.Row
con.execute('''PRAGMA synchronous=OFF''')
return con
class BotsConnection(sqlite.Connection):
import re
reformatparamstyle = re.compile(u'%\((?P<name>[^)]+)\)s')
#~ #bots engine uses:
#~ ''' SELECT *
#~ FROM ta
#~ WHERE idta=%(idta)s ''',
#~ {'idta':12345})
#~ #SQLite wants:
#~ ''' SELECT *
#~ FROM ta
#~ WHERE idta=:idta ''',
#~ {'idta': 12345}
sqlite.register_adapter(bool, lambda s: '1' if s else '0')
sqlite.register_converter('BOOLEAN', lambda s: s == '1')
def connect(database):
con = sqlite.connect(database, factory=BotsConnection,detect_types=sqlite.PARSE_DECLTYPES, timeout=99.0, isolation_level='EXCLUSIVE')
con.row_factory = sqlite.Row
con.execute('''PRAGMA synchronous=OFF''')
return con
class BotsConnection(sqlite.Connection):
def cursor(self):
return sqlite.Connection.cursor(self, factory=BotsCursor)
class BotsCursor(sqlite.Cursor):
def execute(self,string,parameters=None):
if parameters is None:
def adapter4bool(boolfrompython):
#SQLite expects a string
if boolfrompython:
return '1'
else:
return '0'
def converter4bool(strfromdb):
#SQLite returns a string
if strfromdb == '1':
return True
else:
return False
sqlite.register_adapter(bool,adapter4bool)
sqlite.register_converter('BOOLEAN',converter4bool)
def connect(database):
con = sqlite.connect(database, factory=BotsConnection,detect_types=sqlite.PARSE_DECLTYPES, timeout=99.0, isolation_level='IMMEDIATE')
con.row_factory = sqlite.Row
con.execute('''PRAGMA synchronous=OFF''')
return con
class BotsConnection(sqlite.Connection):
def cursor(self):
return sqlite.Connection.cursor(self, factory=BotsCursor)
class BotsCursor(sqlite.Cursor):
def execute(self,string,parameters=None):
if parameters is None:
warnings.warn(u"SQLite received a naive datetime (%s)"
u" while time zone support is active." % value,
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
value = timezone.make_aware(value, default_timezone)
value = value.astimezone(timezone.utc).replace(tzinfo=None)
return value.isoformat(b" ")
Database.register_converter(b"bool", lambda s: str(s) == '1')
Database.register_converter(b"time", parse_time)
Database.register_converter(b"date", parse_date)
Database.register_converter(b"datetime", parse_datetime_with_timezone_support)
Database.register_converter(b"timestamp", parse_datetime_with_timezone_support)
Database.register_converter(b"TIMESTAMP", parse_datetime_with_timezone_support)
Database.register_converter(b"decimal", util.typecast_decimal)
Database.register_adapter(datetime.datetime, adapt_datetime_with_timezone_support)
Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
if Database.version_info >= (2, 4, 1):
# Starting in 2.4.1, the str type is not accepted anymore, therefore,
# we convert all str objects to Unicode
# As registering a adapter for a primitive type causes a small
# slow-down, this adapter is only registered for sqlite3 versions
# needing it (Python 2.6 and up).
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeString, lambda s: s.decode('utf-8'))
class DatabaseFeatures(BaseDatabaseFeatures):
# SQLite cannot handle us only partially reading from a cursor's result set
# and then writing the same rows to the database in another cursor. This
# setting ensures we always read result sets fully into memory all in one
# go.
from pysqlite2 import dbapi2 as sqlite
class Point(object):
def __init__(self, x, y):
self.x, self.y = x, y
def adapt_point(point):
return "%f;%f" % (point.x, point.y)
sqlite.register_adapter(Point, adapt_point)
con = sqlite.connect(":memory:")
cur = con.cursor()
p = Point(4.0, -3.2)
cur.execute("select ?", (p,))
print cur.fetchone()[0]
import sys
from peewee import ImproperlyConfigured
from peewee import sqlite3
from playhouse.sqlite_ext import *
sqlite3_lib_version = sqlite3.sqlite_version_info
# Peewee assumes that the `pysqlite2` module was compiled against the
# BerkeleyDB SQLite libraries.
try:
from pysqlite2 import dbapi2 as berkeleydb
except ImportError:
import sqlite3 as berkeleydb
berkeleydb.register_adapter(decimal.Decimal, str)
berkeleydb.register_adapter(datetime.date, str)
berkeleydb.register_adapter(datetime.time, str)
class BerkeleyDatabase(SqliteExtDatabase):
def __init__(self, database, pragmas=None, cache_size=None, page_size=None,
multiversion=None, *args, **kwargs):
super(BerkeleyDatabase, self).__init__(
database, pragmas=pragmas, *args, **kwargs)
if multiversion:
self._pragmas.append(('multiversion', 'on'))
if page_size:
self._pragmas.append(('page_size', page_size))
if cache_size:
self._pragmas.append(('cache_size', cache_size))
class DBExcept(Exception):
pass
class khash(str):
"""Dummy class to convert all hashes to base64 for storing in the DB."""
class dht_value(str):
"""Dummy class to convert all DHT values to base64 for storing in the DB."""
# Initialize the database to work with 'khash' objects (binary strings)
sqlite.register_adapter(khash, b2a_base64)
sqlite.register_converter("KHASH", a2b_base64)
sqlite.register_converter("khash", a2b_base64)
# Initialize the database to work with DHT values (binary strings)
sqlite.register_adapter(dht_value, b2a_base64)
sqlite.register_converter("DHT_VALUE", a2b_base64)
sqlite.register_converter("dht_value", a2b_base64)
class DB:
"""An sqlite database for storing persistent node info and key/value pairs.
@type db: C{string}
@ivar db: the database file to use
@type conn: L{pysqlite2.dbapi2.Connection}
def sql_format(self, type_, value):
if type_ in ('INTEGER', 'BIGINT'):
if (value is not None and not isinstance(value,
(Query, Expression))):
value = int(value)
return value
def json_get(self, column, key=None):
if key:
column = JSONExtract(column, '$.%s' % key)
return NullIf(JSONQuote(column), JSONQuote(Null))
sqlite.register_converter('NUMERIC', lambda val: Decimal(val.decode('utf-8')))
sqlite.register_adapter(Decimal, lambda val: str(val).encode('utf-8'))
def adapt_datetime(val):
return val.replace(tzinfo=None).isoformat(" ")
sqlite.register_adapter(datetime.datetime, adapt_datetime)
sqlite.register_adapter(datetime.time, lambda val: val.isoformat())
sqlite.register_converter(
'TIME', lambda val: datetime.time(*map(int,
val.decode('utf-8').split(':'))))
sqlite.register_adapter(datetime.timedelta, lambda val: val.total_seconds())
def convert_interval(value):
def lastid(self, cursor):
# This call is not thread safe
return cursor.lastrowid
def lock(self, connection, table):
pass
def has_constraint(self):
return False
def has_multirow_insert(self):
return True
sqlite.register_converter('NUMERIC', lambda val: Decimal(val.decode('utf-8')))
if sys.version_info[0] == 2:
sqlite.register_adapter(Decimal, lambda val: buffer(str(val)))
sqlite.register_adapter(bytearray, lambda val: buffer(val))
else:
sqlite.register_adapter(Decimal, lambda val: str(val).encode('utf-8'))
def adapt_datetime(val):
return val.replace(tzinfo=None).isoformat(" ")
sqlite.register_adapter(datetime.datetime, adapt_datetime)
sqlite.register_adapter(datetime.time, lambda val: val.isoformat())
sqlite.register_converter('TIME', lambda val: datetime.time(*map(int,
val.decode('utf-8').split(':'))))
sqlite.register_adapter(datetime.timedelta, lambda val: val.total_seconds())
def convert_interval(value):
def decoder(conv_func):
""" The Python sqlite3 interface returns always byte strings.
This function converts the received value to a regular string before
passing it to the receiver function.
"""
return lambda s: conv_func(s.decode('utf-8'))
Database.register_converter(str("bool"), decoder(lambda s: s == '1'))
Database.register_converter(str("time"), decoder(parse_time))
Database.register_converter(str("date"), decoder(parse_date))
Database.register_converter(str("datetime"), decoder(parse_datetime_with_timezone_support))
Database.register_converter(str("timestamp"), decoder(parse_datetime_with_timezone_support))
Database.register_converter(str("TIMESTAMP"), decoder(parse_datetime_with_timezone_support))
Database.register_converter(str("decimal"), decoder(backend_utils.typecast_decimal))
Database.register_adapter(datetime.datetime, adapt_datetime_with_timezone_support)
Database.register_adapter(decimal.Decimal, backend_utils.rev_typecast_decimal)
if six.PY2:
Database.register_adapter(str, lambda s: s.decode('utf-8'))
Database.register_adapter(SafeBytes, lambda s: s.decode('utf-8'))
class DatabaseFeatures(BaseDatabaseFeatures):
# SQLite cannot handle us only partially reading from a cursor's result set
# and then writing the same rows to the database in another cursor. This
# setting ensures we always read result sets fully into memory all in one
# go.
can_use_chunked_reads = False
test_db_allows_multiple_connections = False
supports_unspecified_pk = True
supports_timezones = False
from pysqlite2 import dbapi2 as sqlite
import datetime, time
def adapt_datetime(ts):
return time.mktime(ts.timetuple())
sqlite.register_adapter(datetime.datetime, adapt_datetime)
con = sqlite.connect(":memory:")
cur = con.cursor()
now = datetime.datetime.now()
cur.execute("select ?", (now, ))
print cur.fetchone()[0]
