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 __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]