SQLite3.

4 using in Python -- Document

Traducido por Ricardo D. Quiroga l2radamanthys@gmail.com SQLite es una biblioteca del C que proporciona una base de datos disco-basado ligera que no requiere un proceso del servidor separado y permite acceder la base de datos que usa una variante del nonstandard del SQL pregunta idioma. Algunas aplicaciones pueden usar SQLite para el almacenamiento de los datos interior. Tambin es posible al prototipo una aplicacin que usa SQLite y entonces pone a babor el cdigo a una base de datos ms grande como PostgreSQL u Oracle. el pysqlite era escrito por Gerhard Hring y proporciona a una interfaz de SQL dcil el DB-API que 2.0 especificacin describi por NIMO 249. Para usar el mdulo, usted debe crear un objeto de Conexin que representa la base de datos primero. Aqu los datos se guardarn en el / el archivo del tmp/example: conn = sqlite3.connect('/tmp/example') Usted tambin puede proporcionar el nombre especial ": la memoria: " para crear una base de datos en la RAM. Una vez usted tiene una Conexin, usted puede crear un objeto del Cursor y puede llamar su ejecute () el mtodo para realizar los rdenes de SQL:

c = conn.cursor() # Crear una tabla c.execute('''create table stocks (date text, trans text, symbol text, qty real, price real)''') # Inserta un campo en la tabla c.execute("""insert into stocks values ('2006-01-05','BUY','RHAT',100,35.14)""") # Guarda (commit) los cambios conn.commit() # cierra la el cursor c.close() Normalmente sus funcionamientos de SQL necesitarn usar los valores de las variables de Python. Usted no debe congregar su pregunta que usa los funcionamientos del cordn de Python porque haciendo para que es inseguro; hace su programa vulnerable a un SQL el ataque inyeccin. En cambio, use la substitucin del parmetro del DB-API. Ponga "? " dondequiera que como un placeholder usted quiere usar un valor, y entonces proporciona un tuple de valores como el segundo argumento al cursor ejecute () el mtodo. (Otros mdulos de la base de datos pueden usar un placeholder diferente, como "% s" o ":1".) por ejemplo:

# Never do this -- insecure! symbol = 'IBM' c.execute("... where symbol = '%s'" % symbol) # Do this instead t = (symbol,) c.execute('select * from stocks where symbol=?', t) # Larger example for t in (('2006-03-28', 'BUY', 'IBM', 1000, 45.00), ('2006-04-05', 'BUY', 'MSOFT', 1000, 72.00), ('2006-04-06', 'SELL', 'IBM', 500, 53.00), ): c.execute('insert into stocks values (?,?,?,?,?)', t) Recuperar los datos despus de ejecutar una declaracin SELECT, usted puede tratar o el cursor como un iterator, llame el fetchone() del cursor el mtodo para recuperar una sola fila emparejando, o llama el fetchall() para conseguir una lista de las filas emparejando. Este ejemplo usa el formulario del iterator: >>> c = conn.cursor() >>> c.execute('select * from stocks order by price') >>> for row in c: ... print row ... (u'2006-01-05', u'BUY', u'RHAT', 100, 35.140000000000001) (u'2006-03-28', u'BUY', u'IBM', 1000, 45.0) (u'2006-04-06', u'SELL', u'IBM', 500, 53.0) (u'2006-04-05', u'BUY', u'MSOFT', 1000, 72.0) >>> Module functions and constants PARSE_DECLTYPES Esta constante se significa ser usada con el parmetro del detect_types del conecte la funcin. Ponindolo hace el mdulo del sqlite3 analizar el tipo declarado para cada columna que devuelve. Analizar fuera la primera palabra del tipo declarado, i. e. para el "entero la llave" primaria, analizar fuera el "entero". Entonces para esa columna, parecer en el diccionario de los conversores y usar la funcin del conversor registrada all para ese tipo. Los nombres del conversor son caso-sensibles! PARSE_COLNAMES Esta constante se significa ser usada con el parmetro del detect_types del conecte la funcin. Poner esto hace al SQLite unir analice el nombre de la columna para cada columna que devuelve. Buscar un cordn formado [el mytype] en all, y entonces decide que 'el mytype' es el tipo de la columna. Intentar encontrar una entrada de 'el mytype' en el diccionario de los conversores y entonces usa la funcin del conversor encontr para devolver el valor all. El nombre de la columna encontrado en cursor.description es slo la primera palabra del nombre de la columna, i. e. si usted usa algo como 'como "x [el datetime] "' entonces en su SQL, nosotros analizaremos fuera todo hasta el primer

espacio en blanco para el nombre de la columna: el nombre de la columna simplemente sera "x." connect( database[, timeout, isolation_level, detect_types, factory]) Abre una conexin a la SQLite base de datos archivo base de datos. Usted puede usar ": la memoria: " para abrir una conexin de la base de datos a una base de datos que reside en la RAM en lugar de en el disco. Cuando una base de datos se accede por las conexiones mltiples, y uno de los procesos modifica la base de datos, la base de datos de SQLite se cierra con llave hasta que esa transaccin se comprometa. El parmetro de la interrupcin especifica cunto tiempo la conexin debe esperar por la cerradura para marcharse hasta levantar una excepcin. El valor predeterminado para el parmetro de la interrupcin es 5.0 (cinco segundos). Para el parmetro del isolation_level, por favor vea la propiedad del isolation_level de objetos de Conexin en seccin 13.13.2. SQLite apoya slo el TEXTO de los tipos nativamente, el ENTERO, el FLOTADOR, SALPICA y NULO. Si usted quiere usar otros tipos, como usted agregar el apoyo por ellos usted tienen. El parmetro del detect_types y los conversores personalizados usando registrados con la funcin del register_converter mdulo-nivelada le permiten hacer eso fcilmente. el detect_types tiene como valor predefinido 0 (i. e. fuera de, ningn descubrimiento del tipo), usted puede ponerlo a cualquier combinacin de PARSE_DECLTYPES y PARSE_COLNAMES encender el descubrimiento del tipo. Por defecto, el mdulo del sqlite3 usa su clase de Conexin para el conecte la llamada. Usted puede, sin embargo, subclass la clase de Conexin y hace conecte el uso en cambio su clase manteniendo su clase el parmetro de la fbrica. Consulte la seccin 13.13.4 de este manual para los detalles. El mdulo del sqlite3 usa un escondite de la declaracin internamente para evitar SQL que analiza sobre la cabeza. Si usted quiere poner el nmero de declaraciones que se esconden para la conexin explcitamente, usted puede poner el parmetro del cached_statements. El valor predeterminado actualmente llevado a cabo es esconder 100 declaraciones. register_converter( typename, callable) Los registros un callable para convertir un bytestring de la base de datos en un tipo de Python personalizado. Los callable se invocarn para todo los valores de la base de datos que son del typename del tipo. Confiera el detect_types del parmetro del conecte la funcin para cmo los trabajos de descubrimiento de tipo. Nota que el caso de typename y el nombre del tipo en su pregunta debe emparejar! register_adapter( type, callable) Los registros un callable para convertir el tipo de tipo de Python personalizado en uno de los tipos apoyados de SQLite. El callable del callable acepta como el solo parmetro el valor de Python, y debe devolver un valor de los tipos siguientes: los int, largo, flotan, str (UTF-8 puso en cdigo), unicode o pulidor. complete_statement( sql) Los ingresos Arreglan si el sql del cordn contiene uno o las declaraciones de SQL ms completas terminadas por los puntos y comas. No verifica que el SQL es

sintcticamente correcto, slo que hay que ningn unclosed ata el literals y la declaracin se termina por un punto y coma. Esto puede usarse para construir una cscara para SQLite, como en el ejemplo siguiente: # A minimal SQLite shell for experiments import sqlite3 con = sqlite3.connect(":memory:") con.isolation_level = None cur = con.cursor() buffer = "" print "Enter your SQL commands to execute in sqlite3." print "Enter a blank line to exit." while True: line = raw_input() if line == "": break buffer += line if sqlite3.complete_statement(buffer): try: buffer = buffer.strip() cur.execute(buffer) if buffer.lstrip().upper().startswith("SELECT"): print cur.fetchall() except sqlite3.Error, e: print "An error occurred:", e.args[0] buffer = "" con.close() # fin del codigo*******************************

enable_callback_tracebacks( flag) Por defecto usted no conseguir ningn tracebacks en las funciones usuariodefinidas, agregados, los conversores, el etc de callbacks de authorizer. Si usted quiere ponerlos a punto, usted puede llamar esta funcin con la bandera como Verdadero. Despus, usted recibir los tracebacks del callbacks en sys.stderr. Use Falso para desactivar el rasgo de nuevo. Objectos de Conecion Un caso de Conexin tiene los atributos siguientes y mtodos: isolation_level Consiga o ponga el nivel de aislamiento actual. Ninguno para modo del autocommit o uno de DIFERIDO, "INMEDIATO" o "EXLUSIVE". Vea `` Controlando las Transacciones '', seccin 13.13.5, para una explicacin ms detallada. cursor( [cursorClass])

El mtodo del cursor acepta un solos cursorClass del parmetro optativos. Si proporcion, sta debe ser una clase del cursor personalizada que extiende sqlite3.Cursor.

execute( sql, [parameters]) ste es un atajo del nonstandard que crea un objeto de cursor de intermedio llamando el mtodo del cursor, entonces llama el cursor ejecute el mtodo con los parmetros dados. executemany( sql, [parameters]) ste es un atajo del nonstandard que crea un objeto de cursor de intermedio llamando el mtodo del cursor, entonces llama el mtodo del executemany del cursor con los parmetros dados. executescript( sql_script) ste es un atajo del nonstandard que crea un objeto de cursor de intermedio llamando el mtodo del cursor, entonces llama el mtodo del executescript del cursor con los parmetros dados. create_function( name, num_params, func) Crea una funcin usuario-definida que usted puede usar despus desde dentro las declaraciones de SQL bajo el nombre de nombre de funcin. el num_params es el nmero de parmetros que la funcin acepta, y el func es un callable de Python que se llama como la funcin de SQL. La funcin puede devolver cualquiera de los tipos apoyado por SQLite: el unicode, el str, que los int, largo, flotan, pulidor y Ninguno. El ejemplo: import sqlite3 import md5 def md5sum(t): return md5.md5(t).hexdigest() con = sqlite3.connect(":memory:") con.create_function("md5", 1, md5sum) cur = con.cursor() cur.execute("select md5(?)", ("foo",)) print cur.fetchone()[0]

create_aggregate( name, num_params, aggregate_class) Crea una funcin agregado usuario-definida. La clase agregado debe llevar a cabo un mtodo del paso que acepta el nmero de num_params de los parmetros y un finalice mtodo que devolver el resultado final del agregado. El finalice el mtodo puede devolver cualquiera de los tipos apoyado por SQLite: el unicode, el str, que los int, largo, flotan, pulidor y Ninguno. El ejemplo:

import sqlite3 class MySum: def __init__(self): self.count = 0 def step(self, value): self.count += value def finalize(self): return self.count con = sqlite3.connect(":memory:") con.create_aggregate("mysum", 1, MySum) cur = con.cursor() cur.execute("create table test(i)") cur.execute("insert into test(i) values (1)") cur.execute("insert into test(i) values (2)") cur.execute("select mysum(i) from test") print cur.fetchone()[0]

create_collation( name, callable) Crea una comparacin con el nombre especificado y callable. Los callable se pasarn dos argumentos del cordn. Debe devolver -1 si el primero se pide baje que el segundo, 0 si les piden igual y 1 si el primero se pide superior que el segundo. Note que esto controla ordenando (el ORDEN POR en SQL) para que sus comparaciones no afectan otros funcionamientos de SQL. La nota que los callable conseguirn sus parmetros como bytestrings de Python que normalmente se pondr en cdigo en UTF-8. El ejemplo siguiente muestra una comparacin personalizada que ordena "la manera" mala: import sqlite3 def collate_reverse(string1, string2): return -cmp(string1, string2) con = sqlite3.connect(":memory:") con.create_collation("reverse", collate_reverse) cur = con.cursor() cur.execute("create table test(x)") cur.executemany("insert into test(x) values (?)", [("a",), ("b",)]) cur.execute("select x from test order by x collate reverse") for row in cur: print row con.close()

Para quitar una comparacin, llame el create_collation con Ninguno como el callable: con.create_collation("reverse", None)

interrupt( ) Usted puede llamar este mtodo de un hilo diferente abortar cualquier pregunta que podra estar ejecutando en la conexin. La pregunta abortar entonces y la visita conseguir una excepcin. set_authorizer( authorizer_callback) Esta rutina registra un callback. El callback se invoca para cada esfuerzo por acceder una columna de una mesa en la base de datos. Los callback deben devolver SQLITE_OK si el acceso se permite, SQLITE_DENY si la declaracin de SQL entera debe abortarse con un error y SQLITE_IGNORE si la columna debe tratarse como un valor NULO. Estas constantes estn disponibles en el mdulo del sqlite3. El primer argumento al callback significa qu tipo de funcionamiento ser autorizado. El segundo y tercer argumento sern los argumentos o Ninguno que depende del primer argumento. El 4 argumento es el nombre de la base de datos ("principal", "temp", etc.) si aplicable. El 5 argumento es el nombre del la interno-mayora gatillo o vista que son responsable para el esfuerzo de acceso o Ninguno si este esfuerzo de acceso es directamente de la entrada el cdigo de SQL. Por favor consulte la documentacin de SQLite sobre los posibles valores por el primer argumento y el significado del segundo y tercer argumento que dependen del primero uno. Todas las constantes necesarias estn disponibles en el mdulo del sqlite3. row_factory Usted puede cambiar este atributo a un callable que acepta el cursor y la fila original como un tuple y devolver la fila del resultado real. Esta manera, usted puede llevar a cabo las maneras ms avanzadas de devolver los resultados, como devolver un objeto que tambin puede acceder las columnas por el nombre. El ejemplo: import sqlite3 def dict_factory(cursor, row): d = {} for idx, col in enumerate(cursor.description): d[col[0]] = row[idx] return d con = sqlite3.connect(":memory:") con.row_factory = dict_factory cur = con.cursor() cur.execute("select 1 as a") print cur.fetchone()["a"]

Si a devolviendo un tuple no basta y usted quiere el acceso nombre-basado a las columnas, usted debe considerar los row_factory de la escena al tipo de sqlite3.Row muy-perfeccionado. La fila proporciona sobre la cabeza a los dos el acceso nombrebasado ndice-basado y caso-insensible a las columnas casi ninguna memoria. Probablemente ser bueno que su propia costumbre acercamiento diccionario-basado o incluso un db_row bas la solucin.

text_factory Usando este atributo usted pueden controlar qu objetos se vuelven para el tipo de datos de TEXTO. Por defecto, este atributo se pone al unicode y el mdulo del sqlite3 devolver los objetos de Unicode para el TEXTO. Si usted quiere devolver el bytestrings en cambio, usted puede ponerlo al str. Por las razones de eficacia, hay tambin una manera de devolver Unicode slo objeta para los datos de non-ASCII, y bytestrings por otra parte. Para activarlo, ponga este atributo a sqlite3.OptimizedUnicode. Usted tambin puede ponerlo a cualquier otro callable que admite el objeto resultante a un solo parmetro del bytestring y a ingresos. Vea el cdigo del ejemplo siguiente para la ilustracin: import sqlite3 con = sqlite3.connect(":memory:") cur = con.cursor() # Create the table con.execute("create table person(lastname, firstname)") AUSTRIA = u"\xd6sterreich" # by default, rows are returned as Unicode cur.execute("select ?", (AUSTRIA,)) row = cur.fetchone() assert row[0] == AUSTRIA # but we can make pysqlite always return bytestrings ... con.text_factory = str cur.execute("select ?", (AUSTRIA,)) row = cur.fetchone() assert type(row[0]) == str # the bytestrings will be encoded in UTF-8, unless you stored garbage in the # database ... assert row[0] == AUSTRIA.encode("utf-8") # we can also implement a custom text_factory ... # here we implement one that will ignore Unicode characters that cannot be # decoded from UTF-8 con.text_factory = lambda x: unicode(x, "utf-8", "ignore") cur.execute("select ?", ("this is latin1 and would normally create errors" + u"\xe4\xf6\xfc".encode("latin1"),)) row = cur.fetchone() assert type(row[0]) == unicode # pysqlite offers a builtin optimized text_factory that will return bytestring # objects, if the data is in ASCII only, and otherwise return unicode objects con.text_factory = sqlite3.OptimizedUnicode cur.execute("select ?", (AUSTRIA,)) row = cur.fetchone()

assert type(row[0]) == unicode

cur.execute("select ?", ("Germany",)) row = cur.fetchone() assert type(row[0]) == str

total_changes Los ingresos el nmero total de filas de la base de datos que se han modificado, insert, o anul desde que la conexin de la base de datos fue abierta. Objecto Cursor El objecto cursor en una instancia tiene los siguientes metodos: execute( sql, [parameters]) Ejecuta una declaracin de SQL. La declaracin de SQL puede ser los parametrized (i. e. el placeholders en lugar del literals de SQL). El mdulo del sqlite3 apoya dos tipos de placeholders: los signos de interrogacin (los qmark llaman) y nombr el placeholders (nombr el estilo). Este ejemplo muestra cmo usar los parmetros con el estilo del qmark: import sqlite3 con = sqlite3.connect("mydb") cur = con.cursor() who = "Yeltsin" age = 72 cur.execute("select name_last, age from people where name_last=? and age=?", (who, age)) print cur.fetchone() Este ejemplo muestra cmo usar el estilo nombrado: import sqlite3 con = sqlite3.connect("mydb") cur = con.cursor() who = "Yeltsin" age = 72 cur.execute("select name_last, age from people where name_last=:who and age=:age", {"who": who, "age": age}) print cur.fetchone()

execute() ejecutar slo una sola declaracin de SQL. Si usted intenta ejecutar ms de una declaracin con l, levantar una Advertencia. Use el executescript () si usted quiere ejecutar las declaraciones de SQL mltiples con una llamada. executemany( sql, seq_of_parameters) Ejecuta un orden de SQL contra todas las sucesiones del parmetro o cartografas encontradas en el sql de la sucesin. El mdulo del sqlite3 tambin permite usar un iterator los parmetros productivos en lugar de una sucesin. import sqlite3 class IterChars: def __init__(self): self.count = ord('a') def __iter__(self): return self def next(self): if self.count > ord('z'): raise StopIteration self.count += 1 return (chr(self.count - 1),) # this is a 1-tuple con = sqlite3.connect(":memory:") cur = con.cursor() cur.execute("create table characters(c)") theIter = IterChars() cur.executemany("insert into characters(c) values (?)", theIter) cur.execute("select c from characters") print cur.fetchall() Aqu es un ejemplo ms corto usando un generador: import sqlite3 def char_generator(): import string for c in string.letters[:26]: yield (c,) con = sqlite3.connect(":memory:") cur = con.cursor() cur.execute("create table characters(c)") cur.executemany("insert into characters(c) values (?)", char_generator()) cur.execute("select c from characters") print cur.fetchall()

executescript( sql_script)

ste es un mtodo de conveniencia de nonstandard por ejecutar las declaraciones de SQL mltiples en seguida. Emite un COMPROMETA la declaracin primero, entonces ejecuta la escritura de SQL que consigue como un parmetro. los sql_script pueden ser un bytestring o un cordn de Unicode. El ejemplo: import sqlite3 con = sqlite3.connect(":memory:") cur = con.cursor() cur.executescript(""" create table person( firstname, lastname, age ); create table book( title, author, published ); insert into book(title, author, published) values ( 'Dirk Gently''s Holistic Detective Agency', 'Douglas Adams', 1987 ); """) rowcount Aunque la clase del Cursor del mdulo del sqlite3 lleva a cabo este atributo, el propio apoyo del artefacto de la base de datos para la determinacin de filas afectada" / filas seleccionadas" son raras. Para las declaraciones SELECTS, el rowcount no es siempre Ninguno porque nosotros no podemos determinar el nmero de filas una pregunta producida hasta que todas las filas fueran sacadas. Para DELECT las declaraciones, SQLite informa el rowcount como 0 si usted hace un DELECT FROM la mesa sin cualquier condicin. Para las declaraciones del executemany, el nmero de modificaciones se resume en el rowcount. Como requerido por Python la DB API Especificacin, el atributo del rowcount "es -1 en caso de que ningn executeXX () se ha realizado en el cursor o el rowcount del ltimo funcionamiento no es determinable por la interfaz."

Tipos de Datos en SQLite y Python

Los tipos de Python siguientes pueden enviarse as a SQLite sin cualquier problema son:

Python type
None int long float str (UTF8-encoded) unicode buffer

SQLite type NULL INTEGER INTEGER REAL TEXT TEXT BLOB

Esto es cmo se convierten los tipos de SQLite por defecto a los tipos de Python:

SQLite type
NULL INTEGER REAL TEXT BLOB

Python type None int or long, depending on size float depends on text_factory, unicode by default buffer

El sistema del tipo del mdulo del sqlite3 es extensible de dos maneras: usted puede guardar Python adicional teclea en una base de datos de SQLite va la adaptacin del objeto, y usted puede permitir al convertido de mdulo de sqlite3 los tipos de SQLite a los tipos de Python diferentes va los conversores. Los adaptadores usando para guardar Python adicional teclean en las bases de datos de SQLite Como descrito antes, SQLite apoya slo un juego limitado de tipos nativamente. Usar otra Python teclea con SQLite, usted debe adaptarlos a uno de los tipos apoyados del mdulo del sqlite3 para SQLite: uno de NoneType, int, largo, el flotador, el str, el unicode, el pulidor. El mdulo del sqlite3 usa la adaptacin de objeto de Python, como descrito en el PEP 246 para esto. El protocolo para usar es PrepareProtocol. Hay dos maneras de permitir al mdulo del sqlite3 adaptar un tipo de Python personalizado a uno de los apoyados.

Permitiendo su objeto adaptarse ste es un acercamiento bueno si usted escribe lo a la clase. Supongamos que usted tiene una clase as: class Point(object): def __init__(self, x, y): self.x, self.y = x, y Ahora usted quiere guardar el punto en una sola columna de SQLite. Primero usted tendr que escoger uno de los tipos apoyados ser usado por representar el punto primero. Simplemente usemos el str y separe las coordenadas que usan un punto y coma. Entonces usted necesita dar un mtodo a su clase __conform__(self, protocolo) qu debe devolver el valor convertido. El protocolo del parmetro ser PrepareProtocol. import sqlite3 class Point(object): def __init__(self, x, y): self.x, self.y = x, y def __conform__(self, protocol): if protocol is sqlite3.PrepareProtocol: return "%f;%f" % (self.x, self.y) con = sqlite3.connect(":memory:") cur = con.cursor() p = Point(4.0, -3.2) cur.execute("select ?", (p,)) print cur.fetchone()[0] Registrando un callable del adaptador La otra posibilidad es crear una funcin que convierte el tipo a la representacin del cordn y registra la funcin con el register_adapter. La nota: Los type/class para adaptar deben ser una clase del nuevo-estilo, i. e. debe tener el objeto como uno de sus bases. import 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] El mdulo del sqlite3 tiene dos adaptadores de valor predeterminado para el datetime.date incorporado de Python y tipos de datetime.datetime. Ahora supongamos nosotros queremos guardar datetime.datetime no objeta en la representacin de ISO, pero como un timestamp de Unix. import sqlite3 import datetime, time def adapt_datetime(ts): return time.mktime(ts.timetuple()) sqlite3.register_adapter(datetime.datetime, adapt_datetime) con = sqlite3.connect(":memory:") cur = con.cursor() now = datetime.datetime.now() cur.execute("select ?", (now,)) print cur.fetchone()[0] Los valores de SQLite convirtiendo a los tipos de Python personalizados Escribiendo un adaptador le permite enviar que Python personalizada teclea a SQLite. Pero para hacerlo muy til nosotros necesitamos hacer Python a SQLite al trabajo de roundtrip de Python. Entre en los conversores. Regresemos a la clase del Punto. Nosotros guardamos los x y coordenadas de y separadas va los puntos y comas como los cordones en SQLite. Primero, nosotros definiremos una funcin del conversor que acepta el cordn como un parmetro y estructuras un objeto del Punto de l. La nota: Siempre se llaman las funciones del conversor con un cordn, no importa bajo que los datos lo teclean envi el valor a SQLite. La nota: Los nombres del conversor se buscan de una manera caso-sensible. def convert_point(s): x, y = map(float, s.split(";")) return Point(x, y) Ahora usted necesita hacer el mdulo del sqlite3 saber que lo que usted selecciona de la base de datos realmente es un punto. Hay dos maneras de hacer esto: -Implcitamente va el tipo declarado -Explcitamente va el nombre de la columna Ambas maneras se describen en `` las Constantes del Mdulo '', seccin 13.13.1, en las entradas para las constantes PARSE_DECLTYPES y PARSE_COLNAMES. El ejemplo siguiente ilustra ambos acercamientos.

import sqlite3 class Point(object): def __init__(self, x, y): self.x, self.y = x, y def __repr__(self): return "(%f;%f)" % (self.x, self.y) def adapt_point(point): return "%f;%f" % (point.x, point.y) def convert_point(s): x, y = map(float, s.split(";")) return Point(x, y) # Register the adapter sqlite3.register_adapter(Point, adapt_point) # Register the converter sqlite3.register_converter("point", convert_point) p = Point(4.0, -3.2) ######################### # 1) Using declared types con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES) cur = con.cursor() cur.execute("create table test(p point)") cur.execute("insert into test(p) values (?)", (p,)) cur.execute("select p from test") print "with declared types:", cur.fetchone()[0] cur.close() con.close() ####################### # 1) Using column names con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES) cur = con.cursor() cur.execute("create table test(p)") cur.execute("insert into test(p) values (?)", (p,)) cur.execute('select p as "p [point]" from test') print "with column names:", cur.fetchone()[0] cur.close() con.close() Los adaptadores predefinidos y conversores Hay adaptadores predefinidos para la fecha y el datetime teclea en el mdulo del datetime. Les enviarn como el ISO dates/ISO timestamps a SQLite. Los conversores predefinidos son registrados bajo la fecha del nombre para datetime.date y bajo el "timestamp" del nombre para datetime.datetime.

Esta manera, usted puede usar el date/timestamps de Python sin cualquier tocar el violn adicional en la mayora de los casos. El formato de los adaptadores tambin es compatible con las SQLite date/time funciones experimentales. El ejemplo siguiente demuestra esto. import sqlite3 import datetime con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES) cur = con.cursor() cur.execute("create table test(d date, ts timestamp)") today = datetime.date.today() now = datetime.datetime.now() cur.execute("insert into test(d, ts) values (?, ?)", (today, now)) cur.execute("select d, ts from test") row = cur.fetchone() print today, "=>", row[0], type(row[0]) print now, "=>", row[1], type(row[1]) cur.execute('select current_date as "d [date]", current_timestamp as "ts [timestamp]"') row = cur.fetchone() print "current_date", row[0], type(row[0]) print "current_timestamp", row[1], type(row[1]) Las Transacciones controlando Por defecto, el mdulo del sqlite3 abre las transacciones implcitamente antes de un Idioma de Modificacin de Datos (DML) la declaracin (es decir INSERT/UPDATE/DELETE/REPLACE), y compromete las transacciones implcitamente antes de un non-DML, declaracin del non-pregunta (i. e. algo de otra manera que SELECT/INSERT/UPDATE/DELETE/REPLACE). As si usted est dentro de una transaccin y emite un orden gusta CREE la MESA..., LIMPIE CON ASPIRADORA, PRAGMA, el mdulo del sqlite3 comprometer implcitamente antes de ejecutar ese orden. Hay dos razones por hacer eso. El primero es que algunos de estos rdenes no trabajan dentro de las transacciones. La otra razn es ese pysqlite necesita guardar huella del estado de la transaccin (si una transaccin es activa o no). Usted puede controlar qu tipo de "BEGIN" implcitamente el pysqlite de las declaraciones ejecuta (o ninguno en absoluto) va el parmetro del isolation_level al conecte la llamada, o va la propiedad del isolation_level de conexiones. Si usted quiere modo del autocommit, entonces el isolation_level fijo a Ninguno. Por otra parte djelo a su valor predeterminado que producir una llanura "BEGIN" la declaracin, o pngalo a uno de los niveles de aislamiento apoyados de SQLite: DIFERIDO, INMEDIATO o EXCLUSIVO.

Cuando el mdulo del sqlite3 necesita guardar huella del estado de la transaccin, usted no debe usar OREGN ROLLBACK o EN el CONFLICTO ROLLBACK en su SQL. En cambio, coja el IntegrityError y llame el mtodo del rollback de la conexin usted.

Usando PySQLite Eficientemente

Los mtodos del atajo usando Usando el nonstandard ejecutan, los executemany y mtodos del executescript de la Conexin objetan, su cdigo puede escribirse ms concisamente porque usted no tiene que crear el (a menudo superfluo) el Cursor objeta explcitamente. En cambio, los objetos del Cursor se crean implcitamente y stos que los mtodos del atajo devuelven a los objetos del cursor. Esta manera, usted puede ejecutar una declaracin SELECT e iterate encima de l usando slo una sola llamada directamente en el objeto de Conexin. import sqlite3 persons = [ ("Hugo", "Boss"), ("Calvin", "Klein") ] con = sqlite3.connect(":memory:") # Create the table con.execute("create table person(firstname, lastname)") # Fill the table con.executemany("insert into person(firstname, lastname) values (?, ?)", persons) # Print the table contents for row in con.execute("select firstname, lastname from person"): print row # Using a dummy WHERE clause to not let SQLite take the shortcut table deletes. print "I just deleted", con.execute("delete from person where 1=1").rowcount, "rows" Las columnas accediendo por el nombre en lugar de por el ndice Un rasgo til del mdulo del sqlite3 es el builtin que la clase de sqlite3.Row dise para ser usada como una fbrica de la fila. Pueden accederse filas envueltas con esta clase los dos por el ndice (como el tuples) y caso-insensiblemente por el nombre: import sqlite3 con = sqlite3.connect("mydb") con.row_factory = sqlite3.Row cur = con.cursor() cur.execute("select name_last, age from people")

for row in assert assert assert assert

cur: row[0] == row["name_last"] row["name_last"] == row["nAmE_lAsT"] row[1] == row["age"] row[1] == row["AgE"]