initial commit

2 files changed, 448 insertions, 0 deletions

diff --git a/files/es/storage/index.html b/files/es/storage/index.html
new file mode 100644
index 0000000000..87e2df368e
--- /dev/null
+++ b/files/es/storage/index.html
@@ -0,0 +1,252 @@
+---
+title: Storage
+slug: Storage
+tags:
+  - Interfaces
+  - Storage
+  - Todas_las_Categorías
+  - Toolkit API
+  - páginas_a_traducir
+---
+<br>
+<p>{{ Fx_minversion_header(2) }}</p>
+<p><strong>Storage</strong> es una API para la  base de datos <a class="external" href="http://www.sqlite.org/">SQLite</a>. Responde a las llamadas entidades de confianza, es decir, componentes internos de Firefox y extensiones. hace referencia completa a todos los métodos y propiedades de las conexiones de la interfaz de la  base de datos, lee <a href="/es/mozIStorageConnection" title="es/mozIStorageConnection">mozIStorageConnection</a>.</p>
+<p>El API está actualmente "unfrozen," lo que significa que está sujeto a cambios en cualquier momento. Es muy probable que el API cambie en la transición entre Firefox 2 y Firefox 3.</p>
+<p> </p>
+<div class="note"><strong>Nota:</strong> Storage no es lo mismo que la característica <a href="/es/DOM/Storage" title="es/DOM/Storage">DOM:Storage</a> que puede ser usada por páginas web para almacenar datos persistentes o la <a href="/es/Session_store_API" title="es/Session_store_API">Session store API</a> (una utilidad <a href="/es/XPCOM" title="es/XPCOM">XPCOM</a> de almacenaje para usar con las extensiones).</div>
+<p> </p>
+<h2 id="Empezando" name="Empezando">Empezando</h2>
+<p>Este documento cubre el API mozStorage y algunas peculiaridades de sqlite. <em>No</em> cubre SQL o el sqlite. Sin embargo, puedes encontrar varios enlaces útiles en la sección <a href="#Ver_tambi.C3.A9n"> Ver también</a>. Para obtener ayuda sobre el API mozStorage, puedes escribir a mozilla.dev.apps.firefox en el servidor de noticias news.mozilla.org. Para reportar errores, usa <a class="link-https" href="https://bugzilla.mozilla.org/enter_bug.cgi?product=Toolkit&amp;component=Storage">Bugzilla</a> (producto "Toolkit", componente "Storage").</p>
+<p>Bueno, aquí vamos. mozStorage fue diseñado igual que muchos otros sistemas de base de datos. El procedimiento general de su uso es:</p>
+<ul> <li>Abre una conexión con la base de datos de tu elección.</li> <li>Crea las sentencias a ejecutar en tu conexión.</li> <li>Agrega los parámetros de las sentencias si es necesario.</li> <li>Ejecuta las sentencias.</li> <li>Comprueba si hay errores.</li> <li>Comienza de nuevo con las sentencias.</li>
+</ul>
+<h2 id="Abrir_una_conexi.C3.B3n" name="Abrir_una_conexi.C3.B3n">Abrir una conexión</h2>
+<p>Para los usuarios de C++: La inicialización del servicio de storage debe hacerse desde el mismo hilo principal.Si lo inicializas por primera vez desde otro hilo, obtendrás un error. Por tanto, si quieres usar el servicio dentro de un hilo, asegúrate de llamar a getService desde el hilo principal para estar seguro de que el servicio ha sido creado.</p>
+<p>Ejemplo de apertura de una conexión a "asdf.sqlite" en el directorio del perfil del usuario, en C++:</p>
+<pre>nsCOMPtr&lt;nsIFile&gt; dbFile;
+rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
+                            getter_AddRefs(dbFile));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = dbFile-&gt;Append(NS_LITERAL_STRING("asdf.sqlite"));
+NS_ENSURE_SUCCESS(rv, rv);
+
+mDBService = do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &amp;rv);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = mDBService-&gt;OpenDatabase(dbFile, getter_AddRefs(mDBConn));
+NS_ENSURE_SUCCESS(rv, rv);
+</pre>
+<p><code>MOZ_STORAGE_SERVICE_CONTRACTID</code> está definido en {{ Source("storage/build/mozStorageCID.h") }}. Su valor es <code>"@mozilla.org/storage/service;1"</code></p>
+<p>Ejemplo en JavaScript:</p>
+<pre>var file = Components.classes["@mozilla.org/file/directory_service;1"]
+                     .getService(Components.interfaces.nsIProperties)
+                     .get("ProfD", Components.interfaces.nsIFile);
+file.append("my_db_file_name.sqlite");
+
+var storageService = Components.classes["@mozilla.org/storage/service;1"]
+                        .getService(Components.interfaces.mozIStorageService);
+var mDBConn = storageService.openDatabase(file);
+</pre>
+<dl> <dd> <div class="note">Nota: La función OpenDatabase está sujeta a cambios. Seguramente será simplificada y ampliada para que sea más difícil meterse en problemas.</div> </dd>
+</dl>
+<p>Sería tentador nombrar a tu base de datos con un nombre terminado en ".sdb" por <strong>s</strong>qlite <strong>d</strong>ata<strong>b</strong>ase, pero esto <em>no es recomendable</em>. Esta extensión es tratada de forma especial por Windows como una extensión para "Application Compatibility Database" y sus cambios están respaldados por el sistema automáticamente como parte del sistema de recuperación del sistema. Esto puede dar lugar a un tratamiento desmesurado de las operaciones del archivo.</p>
+<h2 id="Sentencias" name="Sentencias">Sentencias</h2>
+<p>Sigue los pasos para crear y ejecutar sentencias SQL en tu base de datos SQLite. Para una completa referencia, lee <a href="/es/MozIStorageStatement" title="es/MozIStorageStatement">mozIStorageStatement</a>.</p>
+<h3 id="Creando_una_sentencia" name="Creando_una_sentencia">Creando una sentencia</h3>
+<p>Hay dos maneras de crear una sentencia. Si no tienes parámetros y la sentencia no devuelve ningún dato, usa <code>mozIStorageConnection.executeSimpleSQL</code>.</p>
+<pre>C++:
+rv = mDBConn-&gt;ExecuteSimpleSQL(NS_LITERAL_CSTRING("CREATE TABLE foo (a INTEGER)"));
+
+JS:
+mDBConn.executeSimpleSQL("CREATE TABLE foo (a INTEGER)");
+</pre>
+<p>De otra forma, deberías preparar la sentencia usando <code>mozIStorageConnection.createStatement</code>:</p>
+<pre>C++:
+nsCOMPtr&lt;mozIStorageStatement&gt; statement;
+rv = mDBConn-&gt;CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM foo WHERE a = ?1"),
+                              getter_AddRefs(statement));
+NS_ENSURE_SUCCESS(rv, rv);
+
+JS:
+var statement = mDBConn.createStatement("SELECT * FROM foo WHERE a = ?1");
+</pre>
+<p>Este ejemplo usa el comodín "?1" para recoger un parámetro devuelto más adelante (lee la próxima sección).</p>
+<p>Una vez que has preparado la sentencia, puedes agrupar su parámetros, ejecutarla y re usarla una y otra vez. Si utilizas una sentencia repetidamente, el uso de sentencias pre compiladas te brindará una mejora notable en la ejecución, ya que las consultas SQL no necesitan ser analizadas cada vez.</p>
+<p>If you are familiar with sqlite, you may know that prepared statements are invalidated when the schema of the database changes. Fortunately, mozIStorageStatement detects the error and will recompile the statement as needed. Therefore, once you create a statement, you don't need to worry when changing the schema; all statements will continue to transparently work.</p>
+<h3 id="Agregar_los_par.C3.A1metros" name="Agregar_los_par.C3.A1metros">Agregar los parámetros</h3>
+<p>Generalmente es mucho mejor agregar los parámetros separadamente, en lugar de intentar construir una sentencia SQL en una cadena conteniendo los parámetros. Entre otras cosas, esto evita el ataque de inyección de SQL, ya que un parámetro suelto nunca podrá ser ejecutado como una sentencia SQL.</p>
+<p>Se agregan los parámetros a una sentencia SQL reemplazando los comodines. Los comodines son llamados por orden, empezando con el "?1", luego el "?2", etcétera. Usa la función BindXXXParameter(0) BindXXXParameter(1)... para cambiar esos comodines.</p>
+<dl> <dd> <div class="note">Presta atención: Los indices en los comodines van a partir de 1. Los indices de las funciones de cambio, empiezan en 0. Esto es: el "?1" corresponde al parámetro 0, "?1" corresponde al parámetro 1, etcétera.</div> </dd>
+</dl>
+<p>Tambien puedes usar parámetros con nombre como: ":ejemplo" en lugar de "?xx".</p>
+<p>Un comodín puede aparecer varias veces en una cadena SQL y todas las veces será reemplazado por el correspondiente valos. Los parámetros que no han sido agragados (unbound) serán interpretados como <code>NULL</code></p>
+<p>Los ejemplos a continuación, usan <code>bindUTF8StringParameter()</code> y <code>bindInt32Parameter()</code>. Para una lista de todas las demás funciones, lee <a href="/es/MozIStorageStatement#Binding_functions" title="es/MozIStorageStatement#Binding_functions">mozIStorageStatement</a>.</p>
+<p>Ejemplo en C++:</p>
+<pre>nsCOMPtr&lt;mozIStorageStatement&gt; statement;
+rv = mDBConn-&gt;CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM foo WHERE a = ?1 AND b &gt; ?2"),
+                              getter_AddRefs(statement));
+NS_ENSURE_SUCCESS(rv, rv);
+rv = statement-&gt;BindUTF8StringParameter(0, "hello"); // "hello" será sustituido por "?1"
+NS_ENSURE_SUCCESS(rv, rv);
+rv = statement-&gt;BindInt32Parameter(1, 1234); // 1234 será sustituido por "?2"
+NS_ENSURE_SUCCESS(rv, rv);
+</pre>
+<p>Ejemplo en JavaScript:</p>
+<pre>var statement = mDBConn.createStatement("SELECT * FROM foo WHERE a = ?1 AND b &gt; ?2");
+statement.bindUTF8StringParameter(0, "hello");
+statement.bindInt32Parameter(1, 1234);
+</pre>
+<p>Si usas parámetros con nombre, deberías usar el método <code>getParameterIndex</code> para obtener el índice del parámetro con nombre. Aquí hay un ejemplo en JavaScript:</p>
+<pre>var statement = mDBConn.createStatement("SELECT * FROM foo WHERE a = :myfirstparam AND b &gt; :mysecondparam");
+
+var firstidx = statement.getParameterIndex(":myfirstparam");
+statement.bindUTF8StringParameter(firstidx, "hello");
+
+var secondidx = statement.getParameterIndex(":mysecondparam");
+statement.bindInt32Parameter(secondidx, 1234);
+</pre>
+<p>Por supuesto, puedes mezclar parámetros con nombre y con índice en la misma consulta:</p>
+<pre>var statement = mDBConn.createStatement("SELECT * FROM foo WHERE a = ?1 AND b &gt; :mysecondparam");
+
+statement.bindUTF8StringParameter(0, "hello");
+// you can also use
+// var firstidx = statement.getParameterIndex("?1");
+// statement.bindUTF8StringParameter(firstidx, "hello");
+
+var secondidx = statement.getParameterIndex(":mysecondparam");
+statement.bindInt32Parameter(secondidx, 1234);
+</pre>
+<p>Si quieres usar la clausula <code>WHERE</code> con una expresión <code>IN ( value-list )</code>, las sentencias de Bindings no funcionarán. En su lugar, construye una cadena. Si no estas usando unstradas del usuario, la seguridad no es una de tus preocupaciones:</p>
+<pre>var ids = "3,21,72,89";
+var sql = "DELETE FROM table WHERE id IN ( "+ ids +" )";
+</pre>
+<h3 id="Ejecutar_una_sentencia" name="Ejecutar_una_sentencia">Ejecutar una sentencia</h3>
+<p>La manera principal de ejecutar una sentencia es con <code>mozIStorageStatement.executeStep</code>. Esta función te permite enumerar todos los resultados (filas / registros) que produzca tu sentencia y te notificará cuando no hay más resultados.</p>
+<p>Después de una llamada a <code>executeStep</code>, debes usar la <strong>función de recogida apropiada</strong> en <a href="/es/MozIStorageValueArray" title="es/MozIStorageValueArray">mozIStorageValueArray</a> para recoger el valor en una fila (mozIStorageStatement implementa mozIStorageValueArray). El ejemplo de abajo sólo usa <code>getInt32()</code>.</p>
+<p>Puedes obtener el tipo de un valor desde <code>mozIStorageValueArray.getTypeOfIndex</code>, que devuelve el tipo de la columna especificada. Ten cuidado: sqlite no es una base de datos que maneje tipos. Si requieres un tipo diferente, sqlite hará lo mejor que pueda para convertirlo, y dará algún tipo por defecto si no lo consigue. Por tanto, es imposible obtener errores de tipo, pero puedes obtener datos extraños como valor devuelto.</p>
+<p>En código C++ se puede también usar las funciones <code>AsInt32</code>, <code>AsDouble</code>, etcétera. que devuelven el valor como un valor más manejable en C++. Ten precaución, sin embargo, ya que no tendrás errores si tu índice es invalido. Es imposible obtener otros errores, yq que sqlite siempre convertirá los tipos, aún si no tienen sentido.</p>
+<p>Ejemplo C++:</p>
+<pre>PRBool hasMoreData;
+while (NS_SUCCEEDED(statement-&gt;ExecuteStep(&amp;hasMoreData)) &amp;&amp; hasMoreData) {
+  PRInt32 value = statement-&gt;AsInt32(0);
+  // use the value...
+}
+</pre>
+<p>Ejemplo Javascript:</p>
+<pre>while (statement.executeStep()) {
+  var value = statement.getInt32(0); // ¡usa la función correcta!
+  // usa el valor...
+}
+</pre>
+<p>La función <code>mozIStorageStatement.execute()</code> es útil cuando no estás obteniendo datos de la sentencia. Lo que hace es ejecutar la sentencia una vez y luego volverla al estado inicial. Esto puede ser útil para las sentencias de inserción, ya que realmente limpia el código:</p>
+<pre>var statement = mDBConn.createStatement("INSERT INTO my_table VALUES (?1)");
+statement.bindInt32Parameter(52);
+statement.execute();
+</pre>
+<p>Este es un ejemplo simple pero completo en JavaScript y XUL, de cómo ejecutar sentencias SQL en una base de datos: <img alt="Image:TTRW2.zip">.</p>
+<h3 id="Re_crear_una_sentencia_.28reset.29" name="Re_crear_una_sentencia_.28reset.29">Re crear una sentencia (reset)</h3>
+<p>Es importante re crear sentencias que no han sido usadas nuevamente. Las sentencias no re creadas, dejarán un bloqueo en las tablas y evitarán que otras sentencias puedan acceder a los datos. Sentencias de lectura no re creadas evitarán que funcionen las sentencias de escritura.</p>
+<p>Cuando los objetos sentencias son liberados, su correspondiente sentencia en la base de datos es liberada. Si estás usando C++ y sabes que todas las referencias serán destruidas, no tienes que re crear explicitamente las sentencias. Además, si usas <code>mozIStorageStatement.execute()</code>, tampoco necesitas re crear explicitamente las sentencias, esta función lo hará por ti. En otro caso, llama a <code>mozIStorageStatement.reset()</code>.</p>
+<p>Los que usáis JavaScript, deberéis aseguraros de re crear las sentencias. Se particularmente escrupuloso con las excepciones. Querrás estar seguro de re crear las sentencias aún si ocurre una excepción, o los accesos subsiguientes pueden no ser posibles. Re crear una sentencia es relativamente poco pesado y no ocurre nada malo si ya ha sido re creada, así que no te preocupes por re creaciones innecesarias.</p>
+<pre>var statement = connection.createStatement(...);
+try {
+  // usa la sentencia...
+} finally {
+  statement.reset();
+}
+</pre>
+<p>Los que usáis C++ debéis hacer lo mismo. Existe un objeto en {{ Source("storage/public/mozStorageHelper.h") }} llamado mozStorageStatementScoper que se asegurará que una sentencia dada sea re creada cuando sales del ámbito. Es muy recomendable que uses este objeto si te es posible.</p>
+<pre>void someClass::someFunction()
+{
+  mozStorageStatementScoper scoper(mStatement)
+  // use the statement
+}
+</pre>
+<h2 id="id_de_la_.C3.BAltima_inserci.C3.B3n" name="id_de_la_.C3.BAltima_inserci.C3.B3n">id de la última inserción</h2>
+<p>Usa la propiedad <code>lastInsertRowID</code> en la conexión para obtener el id (id de la fila) de la última operación <code>INSERT</code> operation en la base de datos.<br>
+Esto es útil si tienes una columna en tu tabla que sea la clave primaria (como <code>INTEGER PRIMARY KEY</code> o <code>INTEGER PRIMARY KEY AUTOINCREMENT</code>) en cuyo caso SQLite asigna automáticamente un valor a cada fila insertada, si tu no proporcionas alguno. <a class="external" href="http://www.sqlite.org/capi3ref.html#sqlite3_last_insert_rowid"></a><a class="external" href="http://www.sqlite.org/faq.html#q1"></a> El valor devuelto es del tipo <code>number</code> en JS y <code>long long</code> en C++.</p>
+<p><code>lastInsertRowID</code> JS example:</p>
+<pre>var sql = "INSERT INTO contacts_table (number_col, name_col) VALUES (?1, ?2)"
+var statement = mDBConn.createStatement(sql);
+    statement.bindUTF8StringParameter(0, number);
+    statement.bindUTF8StringParameter(1, name);
+    statement.execute();
+    statement.reset();
+
+var rowid = mDBConn.lastInsertRowID;
+</pre>
+<h2 id="Transacciones" name="Transacciones">Transacciones</h2>
+<p>mozIStorageConnection tiene funciones para las transacciones de comienzo y final. Si no usas transacciones explicitamente, se creará una transacción implícita por ti para cada sentencia. Esto tiene una gran implicación en el rendimiento. Hay una sobrecarga en cada transacción, especialmente para las transacciones de confianza. Por tanto verás una apreciable ganancia en el rendimiento, cuando estés haciendo ejecutando varias sentencias en una fila, si las agrupas en una transacción. Ver <a href="/es/Storage/Performance" title="es/Storage/Performance">Storage:Performance</a> para más detalles.</p>
+<p>La mayor diferencia entre otros sitemas de base de datos y sqlite es que éste último no implementa transacciones anidadas. Esto significa que en el momento en que una transacción es abierta, no puedes abrir otra transacción. Puedes usar <code>mozIStorageConnection.transactionInProgress</code> para ver si la transacción está en progreso.</p>
+<p>También puedes simplemente ejecutar "BEGIN TRANSACTION" y "END TRANSACTION" directamente como sentencias SQL (esto es lo que hace la conexión cuando llamas a las funciones). Sin embargo, el uso de <code>mozIStorageConnection.beginTransaction</code> y las funciones relacionadas, está <em>fuertemente</em> recomendado, ya que guarda el estado de la transacción en la conexión. De otra forma, el atributo <code>transactionInProgress</code> tendrá el valor erróneo.</p>
+<p>sqlite tiene vario tipos de transacción:</p>
+<ul> <li>mozIStorageConnection.TRANSACTION_DEFERRED: Por defecto. El bloqueo de la base de datos es adquirido cuando es necesario (generalmente cuando ejecutas una sentencia, por primera vez, en una transacción).</li>
+</ul>
+<ul> <li>mozIStorageConnection.TRANSACTION_IMMEDIATE: Adquiere inmediatamente, un bloqueo de lectura en la base de datos.immediately.</li>
+</ul>
+<ul> <li>mozIStorageConnection.TRANSACTION_EXCLUSIVE: Adquiere inmediatamente, un bloqueo de escritura en la base de datos.immediately.</li>
+</ul>
+<p>Puedes pasar este tipo de transacción a <code>mozIStorageConnection.beginTransactionAs</code> para determinar que clase de transacción necesitas. Recuerda que si ya se ha iniciado otra transacción, esta operación no tendrá éxito. Generalmente, el tipo por defecto de TRANSACTION_DEFERRED es suficiente y no deberías usar otro tipo, a no ser, que realmente sepas porqué lo necesitas. Para más información, lee la documentación de sqlite: <a class="external" href="http://www.sqlite.org/lang_transaction.html">BEGIN TRANSACTION</a> y <a class="external" href="http://www.sqlite.org/lockingv3.html">locking</a>.</p>
+<pre>var ourTransaction = false;
+if (!mDBConn.transactionInProgress) {
+  ourTransaction = true;
+  mDBConn.beginTransactionAs(mDBConn.TRANSACTION_DEFERRED);
+}
+
+// ... usa la conexión ...
+
+if (ourTransaction)
+  mDBConn.commitTransaction();
+</pre>
+<p>A partir de código C++, puedes usar la clase mozStorageTransaction definida en {{ Source("storage/public/mozStorageHelper.h") }}. Esta clase iniciará una transacción del tipo especificado en la conexión especificada y, cuando salga del entorno, bien confiará o bien volverá la transacción a su estado inicial. Si ya hay una transacción en progreso, la clase de ayuda de la transacción no hará nada.</p>
+<p>También tiene funciones de confianza explicitas. El uso típico es que crees la clase que por defecto vuelva a su estado original (rollback) y luego realices la confianza de la transacción explicitamente cuando tenga éxito:</p>
+<pre>nsresult someFunction()
+{
+  // deferred transaction (the default) with rollback on failure
+  mozStorageTransaction transaction(mDBConn, PR_FALSE);
+
+  // ... use the connection ...
+
+  // everything succeeded, now explicitly commit
+  return transaction.Commit();
+}
+</pre>
+<h2 id="C.C3.B3mo_corromper_tu_base_de_datos" name="C.C3.B3mo_corromper_tu_base_de_datos">Cómo corromper tu base de datos</h2>
+<ul> <li>Lee este documento: <a class="external" href="http://www.sqlite.org/lockingv3.html">File locking and concurrency in sqlite version 3</a>, especialmente la sección sobre corrupción.</li>
+</ul>
+<ul> <li>Abre más de una conexión hacia el mismo archivo con nombres que no son exactaente los determinados por <code>strcmp</code>. Esto incluye "my.db" y "../dir/my.db" o, en Windows (sin diferencia Mayúsculas/minúsculas) "my.db" y "My.db". Sqlite intentará manejar muchos de estos casos, pero no debes porfiar en ello.</li>
+</ul>
+<ul> <li>Accede una base de datos desde un enlace simbólico.</li>
+</ul>
+<ul> <li>Abre conexiones a la misma base de datos desde más de un hilo (Ver Seguridad de los hilos" más abajo).</li>
+</ul>
+<ul> <li>Accede a una conexión o a una sentencia desde más de un hilo (Ver Seguridad de los hilos" más abajo).</li>
+</ul>
+<ul> <li>Abre la base de datos desde un programa externo mientras está abierto en Mozilla. Nuestro sistema de cache rompe la reglas normales de bloqueo de archivos en sqlite que permitirían hacer esto de forma segura.</li>
+</ul>
+<h2 id="Bloqueo_en_SQLite" name="Bloqueo_en_SQLite">Bloqueo en SQLite</h2>
+<p>SQLite bloquea la base de datos enteramente, esto es, cualquier intento de lectura causará un que intento de escritura devuelva SQLITE_BUSY, y una escritura activa causará que cualquier intento de lectura devuelva SQLITE_BUSY. Una sentencia es considerada activa a partir del primer step() hasta que se llame a reset(). execute() llama a step() y reset() a un tiempo. Un problema común es olvidar reset() una sentencia después de haber terminado con step().</p>
+<p>Mientras que una conexión SQLite dada es capaz de tener muchas sentencias abiertas, su modelo de bloqueo limita lo que estas sentencias pueden realmente hacer simultáneamente (leer o escribir). De hecho es posible que muchas sentencias estén leyendo al mismo tiempo, sin embargo, no es posible que varias sentencias estén leyendo y escribiendo a la vez <em>en la misma tabla</em> -- aún cuando deriven de la misma conexión.</p>
+<p>El modelo de bloque de SQLite se conoce como "two-tiered": nivel de conexión y nivel de tabla. La mayoría de las personas están familiarizadas con el nivel de conexión (base de datos): múltiples lecturas pero solo una escritura. El nivel de tabla (B-Tree) es lo que a veces puede resultar confuso. (Internamente, cada tabla en la base de datos tiene su propio B-Tree, de modo que tabla y "B-Tree" son técnicamente sinonimos).</p>
+<h3 id="Bloqueo_a_nivel_de_tabla" name="Bloqueo_a_nivel_de_tabla">Bloqueo a nivel de tabla</h3>
+<p>Podrías pensar que si tienes sólo una conexión, i esta bloquea la base da datos para escritura, podrías usar multiples sentencias para hacer lo que quieras. No exactamente. Debes tener en cuenta que los bloqueos a nivel de tabla (B-Tree) que están mantenidos por sentencias se mantienen a lo largo de la base de datos (por ejemplo, las sentencias de manejo SELECT).</p>
+<p>La regla general es esta: una sentencia de manejo puede <strong>not</strong> modificar una tabla (B-Tree) que otras sentencias de manejo están leyendo (tienen el cursor abierto sobre ellas) -- aún cuando la sentencia de manejo comparte la misma conexión (contenido de la transacción, bloqueo de la base de datos, etcétera) con las otras sentencias de manejo. <em>Intentar hacer eso, también bloqueará (o devolverá SQLITE_BUSY)</em>.</p>
+<p>Este problema a menudo aparece cuando intestas interactuar en una tabla usando una sentencia mientras modificas registros en la tabla con otra sentencia. Esto no funcionará (o entraña muchas posibilidades de no funcionar, dependiendo del optimizador (ver más abajo)). Las sentencias de modificación causarán un bloque ya que la sentencia de lectura tiene el cursor abierto sobre la tabla.</p>
+<h3 id="Trabajando_con_los_problemas_de_bloqueo" name="Trabajando_con_los_problemas_de_bloqueo">Trabajando con los problemas de bloqueo</h3>
+<p>La solución es seguir (1) como se dice más arriba. Teóricamente, (2) actualmente no debería funcionar con SQLite 3.x En este escenario, los bloqueos de base de datos entran en juego (con múltiples conexiones) adicionalmente a los bloqueos de tablas. La conexión 2 (conexiones de cambio) no serán capaces de modificar (escribir en) la base de datos mientras que la conexión 1 (conexión de lectura) esté leyendo. La conexión 2 requerirá un bloqueo exclusivo para ejecutar una sentencia de modificación SQL, que no podrá obtener mientras la conexión 1 tenga sentencias activas leyendo la base de datos (La conexión 1 tiene un bloqueo de lectura compartido durante este tiempo que prohíbe a cualquier otra conexión tener un bloqueo exclusivo).</p>
+<p>Otra opción es usar una tabla temporal. Crea una tabla temporal que contenga los resultados de la tabla de interés, interactúa con ella (poniendo los bloqueos de la tabla con las sentencias de lectura en la tabla temporal) y entonces las sentencias de modificación pueden hacer cambios en la tabla real sin ningún problema). Esto puede hacerse con sentencias derivadas de una conexión simple (contexto de la transacción). Esta escena ocurre algunas veces 'detrás del escenario' ya que ORDERED BY puede producir tablas temporales internamente. Sin embargo, no es seguro asumir que el optimizador hará esto en todos los casos. Crear tablas temporales explicitamente, es la única forma segura de realizar esta última opción.</p>
+<h2 id="Seguridad_de_los_hilos" name="Seguridad_de_los_hilos">Seguridad de los hilos</h2>
+<p>El servicio mozStorage y sqlite son hilos seguros. Sin embargo, ningún otro mozStorage u objeto sqlite son hilos seguros.</p>
+<ul> <li>El servicio storage debe ser creado en el hilo principal. Si quieres acceder al servicio desde otro hilo, debes asegurarte de llamar a getService desde el hilo principal con antelación.</li>
+</ul>
+<ul> <li>No puedes acceder a una conexión o una sentencia desde múltiples hilos. Esos objetos storage no son seguros y las representaciones sqlite tampoco son seguras. Aún cuando hagas bloqueo y te asegures que sólo ese hilo está haciendo algo, puede haber problemas. Este caso no ha sido probado y puede haber algún estado pre-implementación en el hilo de sqlite. Se recomienda fuertemente que no hagas esto.</li>
+</ul>
+<ul> <li>No puedes acceder una base de datos simple desde múltiples conexiones en múltiples hilos. Normalmente, sqlite permite esto. Sin embargo, hacemos <code>sqlite3_enable_shared_cache(1);</code> (ver <a class="external" href="http://www.sqlite.org/sharedcache.html">sqlite shared-cache mode</a>) que hace que múltiples conexiones compartan la misma memoria cache. Esto es importante para el rendimiento. Sin embargo, no hay bloqueos para el acceso a la memoria cache, lo que significa que se romperá si se usa desde más de un hilo.</li>
+</ul>
+<p>De nada vale, sin embargo, que los autores de las extensiones de JavaScript del navegador, esten menos impactados por estas restricciones de lo que estaban al principio. Si una base de datos es creada y usada de forma exclusiva desde JavaScript, la seguridad de los hilos no será, normalmente, una preocupación. El motor JavaScript interno de Firefox (SpiderMonkey) ejecuta el JavaScript dentro de un único y persistente hilo, excepto cuando JavaScript se ejecuta en un hilo diferente o es ejecutado a partir de una llamada realizada desde otro hilo (p.e. desde interfaces de stream o delde la red). Con excepción del uso incorrecto de JavaScript en múltiples hilos, los problemas solo deberían ocurrir si se accede aun hilo asociado a una base de datos previamente en uso a través de mozStorage.</p>
+<h2 id="Ver_tambi.C3.A9n" name="Ver_tambi.C3.A9n">Ver también</h2>
+<ul> <li><a href="/es/mozIStorageConnection" title="es/mozIStorageConnection">mozIStorageConnection</a> Conexión de la base de datos a un archivo específico o almacenamiento en memoria.</li> <li><a href="/es/MozIStorageStatement" title="es/MozIStorageStatement">mozIStorageStatement</a> Crea y ejecuta sentencias SQL en bases de datos SQLite.</li> <li><a href="/es/MozIStorageValueArray" title="es/MozIStorageValueArray">mozIStorageValueArray</a> Agrupa una matriz de valores SQL, como una fila resultante.</li> <li><a href="/es/MozIStorageFunction" title="es/MozIStorageFunction">mozIStorageFunction</a> Crea una nueva función SQLite.</li> <li><a href="/es/MozIStorageAggregateFunction" title="es/MozIStorageAggregateFunction">mozIStorageAggregateFunction</a> Crea una nueva función agregada SQLite.</li> <li><a href="/es/MozIStorageProgressHandler" title="es/MozIStorageProgressHandler">mozIStorageProgressHandler</a> Vigilar progresos durante la ejecución de una sentencia.</li> <li><a href="/es/MozIStorageStatementWrapper" title="es/MozIStorageStatementWrapper">mozIStorageStatementWrapper</a> Agrupador de la sentencia Storage.</li> <li><a href="/es/MozIStorageService" title="es/MozIStorageService">mozIStorageService</a> Servicio Storage.</li>
+</ul>
+<ul> <li><a href="/es/Storage/Performance" title="es/Storage/Performance">Storage:Rendimiento</a> Cómo hacer que tu conexión de base de datos rinda bien.</li> <li><a class="link-https" href="https://addons.mozilla.org/en-US/firefox/addon/3072">Storage Inspector Extension</a><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span><span class="short_text" id="result_box"><span title=""><br> </span></span></span> <span class="short_text" id="result_box"><span title="">Hace que sea fácil de ver los archivos de base de datos SQLite en el perfil actual.</span></span></li> <li><a class="external" href="http://www.sqlite.org/lang.html">SQLite Syntax</a> Query <span class="short_text" id="result_box"><span style="" title="">lengua que comprenda </span></span>SQLite</li> <li><a class="external" href="http://sqlitebrowser.sourceforge.net/">SQLite Database Browser</a><span class="medium_text" id="result_box"><span title="">es una herramienta capaz libre disponible para muchas plataformas. </span><span title="">Puede ser útil para examinar las bases de datos existentes y las pruebas sentencias SQL.</span></span> <span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></li> <li><a class="link-https" href="https://addons.mozilla.org/en-US/firefox/addon/5817">SQLite Manager Extension</a><span class="short_text" id="result_box"><span style="background-color: rgb(255, 255, 255);" title="">ayuda a administrar los archivos de base de datos SQLite en el equipo.</span></span> <span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span> <div class="almost_half_cell" style=""> <div dir="ltr" style=""><span class="short_text" id="result_box"><span style="background-color: rgb(255, 255, 255);" title=""><br> </span></span></div> </div> </li>
+</ul>
+<p> </p>
+<p>{{ languages( { "es": "es/Almacenamiento", "fr": "fr/Storage", "ja": "ja/Storage", "pl": "pl/Storage", "en": "en/Storage" } ) }}</p>
diff --git a/files/es/storage/performance/index.html b/files/es/storage/performance/index.html
new file mode 100644
index 0000000000..91f15d4cb2
--- /dev/null
+++ b/files/es/storage/performance/index.html
@@ -0,0 +1,196 @@
+---
+title: Rendimiento
+slug: Storage/Performance
+translation_of: Mozilla/Tech/XPCOM/Storage/Performance
+---
+<p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+<div class="almost_half_cell" style="">
+ <div dir="ltr" style="">
+  <div id="tts_button" style="display: none;" title="Escuchar
+traducción">
+   &lt;object width="18" height="18" id="tts_flash" data="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>" type="application/x-shockwave-flash"&gt; &lt;param name="movie" value="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>"/&gt; &lt;param name="flashvars" value="sound_name=&amp;amp;sound_name_cb=_TTSSoundFile"/&gt; &lt;param name="wmode" value="transparent"/&gt; &lt;param name="allowScriptAccess" value="always"/&gt;&lt;/object&gt;</div>
+  <span class="long_text" id="result_box"><span title=""><a href="/es/Storage" title="https://developer.mozilla.org/es/Storage">mozStorage</a> utiliza <a class="external" href="http://es.wikipedia.org/wiki/SQLite" title="http://es.wikipedia.org/wiki/SQLite">SQLite</a> como servidor. </span><span style="background-color: rgb(255, 255, 255);" title="">Cuenta con el rendimiento generalmente bueno para una pequeña base de datos integrados. </span><span title="">Sin embargo, muchas cosas causan varias operaciones de base de datos a ser lenta.</span></span></div>
+ <p> </p>
+</div>
+<h2 id="Transacciones">Transacciones</h2>
+<p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13
+zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+<div id="tts_button" style="display: none;" title="Escuchar
+traducción">
+ &lt;object width="18" height="18" id="tts_flash" data="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>" type="application/x-shockwave-flash"&gt; &lt;param name="movie" value="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>"/&gt; &lt;param name="flashvars" value="sound_name=&amp;amp;sound_name_cb=_TTSSoundFile"/&gt; &lt;param name="wmode" value="transparent"/&gt; &lt;param name="allowScriptAccess" value="always"/&gt;&lt;/object&gt;</div>
+<p> </p>
+<p><br>
+ <span class="long_text" id="result_box"><span title="">Editar la sección</span><br>
+ <br>
+ <span style="background-color: rgb(255, 255, 255);" title="">No hay sobrecarga asociada con cada transacción. Cuando se ejecuta una SQL de forma aislada, una transacción implícita se crea alrededor de esa declaración. </span><span style="background-color: rgb(255, 255, 255);" title="">Cuando las transacciones se han comprometido, sqlite es el diario que requiere la sincronización de datos en el disco. </span><span title="">Esta operación es extremadamente lento. </span><span title="">Por lo tanto, si usted está haciendo muchas de las transacciones en una fila, obtendrás mejoras significativas en el rendimiento de las rodea en una transacción.</span><br>
+ <br>
+ <span style="background-color: rgb(255, 255, 255);" title="">Si usted no está usando el almacenamiento en caché avanzadas más adelante, la caché de base de datos en memoria se borra al final de cada transacción. </span><span style="background-color: rgb(255, 255, 255);" title="">Esta es otra razón para utilizar las transacciones, incluso si sólo está ejecutando operaciones de lectura.</span><br>
+ <br>
+ <span style="background-color: rgb(255, 255, 255);" title="">El asincrónico escribe discuten a continuación elimina la mayor parte de la pena inmediata de una comisión, por lo que no notará el problema como mucho. </span><span style="background-color: rgb(255, 255, 255);" title="">Sin embargo, todavía hay sobrecarga, y el uso de una transacción seguirá siendo más rápido. </span><span style="background-color: rgb(255, 255, 255);" title="">Un gran problema es que la cola de operaciones de archivo tendrá mucho tiempo si hay muchas operaciones. </span><span style="background-color: rgb(255, 255, 255);" title="">Algunas operaciones requieren caminar esta cola para ver qué operaciones han estado pendientes, y que será más lento. </span><span style="background-color: rgb(255, 255, 255);" title="">Si el usuario cierra el navegador pronto después de hacer este tipo de operaciones, puede retrasar el apagado (posiblemente durante decenas de segundos para que un gran número de transacciones y discos lentos), lo que hace que parezca que el navegador se cuelga.</span></span></p>
+<p> </p>
+<h3 class="editable" id="Consultas"><span>Consultas</span></h3>
+<div class="editIcon">
+ <a href="/../../../../en/Storage/Performance#" style="" title="Edit section"><span class="icon"><img alt="Edit section" class="sectionedit" src="../../../../skins/common/icons/icon-trans.gif"></span></a></div>
+<p><br>
+ <span class="long_text" id="result_box"><span title="">Reordenación de la atención de la declaración SQL, o la creación de los índices adecuada, a menudo puede mejorar el rendimiento. </span><span title="">Véase la descripción general del optimizador sqlite en el sitio web de sqlite para información sobre cómo utiliza los índices de sqlite y ejecuta sentencias.</span><br>
+ <br>
+ <span title="">Usted también puede tratar de la "explicar" en función de sus estados de cuenta para ver si están utilizando los índices que usted espera. </span><span title="">Tipo de "explicar", seguido de su estado de cuenta para ver el plan. </span><span title="">Por ejemplo, explicar select * from moz_history; Los resultados son difíciles de entender, pero usted debería ser capaz de ver si es la utilización de índices. </span><span title="">Un comando que le dará una visión general de alto nivel es "explicar plan de consulta". </span><span title="">Por ejemplo:</span></span></p>
+<pre>sqlite&gt; explain query plan select * from moz_historyvisit v join moz_history h
+        on v.page_id = h.id where v.visit_date &gt; 1000000000;
+
+0|0|TABLE moz_historyvisit AS v WITH INDEX moz_historyvisit_dateindex
+1|1|TABLE moz_history AS h USING PRIMARY KEY</pre>
+<p><span class="long_text" id="result_box"><span title="">Esto nos dice que primero buscará en moz_historyvisit partir de un índice, y luego buscará en moz_history utilizando la clave principal. </span><span title="">Ambas son "buenas" porque utilizan índices y claves principales, que son rápidos.</span></span></p>
+<p> </p>
+<pre>sqlite&gt; explain query plan select * from moz_historyvisit where session = 12;
+
+0|0|TABLE moz_historyvisit</pre>
+<p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+<div class="almost_half_cell" style="">
+ <div dir="ltr" style="">
+  <div id="tts_button" style="display: none;" title="Escuchar
+traducción">
+   &lt;object width="18" height="18" id="tts_flash" data="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>" type="application/x-shockwave-flash"&gt; &lt;param name="movie" value="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>"/&gt; &lt;param name="flashvars" value="sound_name=&amp;amp;sound_name_cb=_TTSSoundFile"/&gt; &lt;param name="wmode" value="transparent"/&gt; &lt;param name="allowScriptAccess" value="always"/&gt;&lt;/object&gt;</div>
+  <p><span class="medium_text" id="result_box"><span title="">En este ejemplo, se puede ver que no está usando un índice, por lo que esta consulta podría ser muy lento.</span></span></p>
+  <p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+  <div class="almost_half_cell" style="">
+   <div dir="ltr" style="">
+    <div id="tts_button" style="display: none;" title="Escuchar
+traducción">
+     &lt;object width="18" height="18" id="tts_flash" data="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>" type="application/x-shockwave-flash"&gt; &lt;param name="movie" value="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>"/&gt; &lt;param name="flashvars" value="sound_name=&amp;amp;sound_name_cb=_TTSSoundFile"/&gt; &lt;param name="wmode" value="transparent"/&gt; &lt;param name="allowScriptAccess" value="always"/&gt;&lt;/object&gt;</div>
+    <span class="long_text" id="result_box"><span title="">Puede descargar la herramienta de línea de comandos desde la <a class="external" href="http://www.sqlite.org/download.html" title="http://www.sqlite.org/download.html">página de descarga sqlite</a>. </span><span title="">Asegúrese de tener una versión de la herramienta de línea de comandos que es al menos tan reciente como lo utiliza Mozilla. </span><span title="">A partir del 10 de abril 2006, Mozilla usa sqlite 3.3.4, pero la última versión precompilada de las herramientas de línea de comandos no está disponible para todas las plataformas. </span><span title="">Esto dará lugar a errores que dicen "base de datos es cifrada" porque la herramienta no es capaz de reconocer el formato de archivo. </span><span title="">Es posible que desee comprobar la definición SQLITE_VERSION en <a class="external" href="http://mxr.mozilla.org/mozilla-central/source/db/sqlite3/src/sqlite3.h" title="http://mxr.mozilla.org/mozilla-central/source/db/sqlite3/src/sqlite3.h">db/sqlite3/src/sqlite3.h</a> para la versión actual si está teniendo problemas.</span></span></div>
+  </div>
+ </div>
+</div>
+<p> </p>
+<p><span id="zippyspan" style="display: block;"><img alt="" class="buttons square13 zippy-plus" id="zippyicon" src="http://www.google.es/images/cleardot.gif" style="margin-right: 0.33em; cursor: pointer;"></span></p>
+<h3 class="editable" id="Caché"><span class="long_text" id="result_box"><span style="background-color: rgb(255, 255, 255);" title="">Caché</span></span></h3>
+<p> </p>
+<div class="editIcon">
+ <a href="/../../../../en/Storage/Performance#" style="" title="Edit section"><span class="icon"><img alt="Edit section" class="sectionedit" src="../../../../skins/common/icons/icon-trans.gif"></span></a></div>
+<p> </p>
+<p><br>
+ <span class="long_text" id="result_box"><span title="">Sqlite tiene un caché de páginas de bases de datos en la memoria. </span><span style="background-color: rgb(255, 255, 255);" title="">Mantiene páginas relacionadas con la transacción actual por lo que puede hacer retroceder, y que además mantiene los utilizados recientemente para que pueda correr más rápido.</span><br>
+ <br>
+ <span style="background-color: rgb(255, 255, 255);" title="">De forma predeterminada, sólo guarda las páginas en la memoria durante una operación (si no explícitamente abierta una transacción, será abierto para usted que rodea cada declaración individual). </span><span title="">Al final de una transacción, el caché se vacía. </span><span title="">Si, posteriormente, iniciar una nueva transacción, las páginas que necesita se volverá a leer el disco (o esperar que el caché de sistema operativo). </span><span title="">Esto hace que incluso bloquear las operaciones simples en los archivos del SO lecturas, que pueden ser prohibitivos en algunos sistemas con cachés de disco malo o unidades de red.</span><br>
+ <br>
+ <span title="">Usted puede controlar el tamaño de la caché de memoria mediante el  </span></span><code>cache_size</code><a class="external" href="http://www.sqlite.org/pragma.html" title="http://www.sqlite.org/pragma.html"><span class="long_text" id="result_box"><span title="">pragma</span></span></a><span class="long_text" id="result_box"><span title="">. </span><span title="">Este valor controla el número de páginas del archivo que se puede guardar en la memoria a la vez. </span><span title="">El tamaño de página se pueden establecer mediante el </span></span><code>page_size</code> pragma<span class="long_text" id="result_box"><span title=""> antes de que las operaciones se han realizado en el archivo. </span><span title="">Puede ver un ejemplo de establecer el tamaño máximo de caché a un porcentaje de la memoria en nsNavHistory:: initdb en <a class="external" href="http://mxr.mozilla.org/mozilla-central/source/toolkit/components/places/src/nsNavHistory.cpp" title="http://mxr.mozilla.org/mozilla-central/source/toolkit/components/places/src/nsNavHistory.cpp">toolkit / components / places / src / nsNavHistory.cpp.</a></span></span></p>
+<p> </p>
+<h4 class="editable" id="El_almacenamiento_en_caché"><span class="long_text" id="result_box"><span style="background-color: rgb(255, 255, 255);" title="">El almacenamiento en caché</span></span></h4>
+<p> </p>
+<div class="editIcon">
+ <a href="/../../../../en/Storage/Performance#" style="" title="Edit section"><span class="icon"><img alt="Edit section" class="sectionedit" src="../../../../skins/common/icons/icon-trans.gif"></span></a></div>
+<p> </p>
+<p><span title="Storage enables the sqlite shared-cache
+mode) which makes multiple connections to the same database share the
+same cache.">Activa el modo de almacenamiento para </span> <a class="external" href="http://www.sqlite.org/sharedcache.html" rel="external nofollow" title="http://www.sqlite.org/sharedcache.html">sqlite shared-cache mode</a><span title="Storage enables the sqlite shared-cache
+mode) which makes multiple connections to the same database share the
+same cache.">), que hace varias conexiones a la parte misma base de datos la misma caché. </span><span title="Because the cache is not threadsafe, this unfortunately means
+that you can not have different connections from different threads
+accessing the same database.">Debido a que el caché no es multi-hilo, esto significa que por desgracia no se puede tener diferentes conexiones desde diferentes subprocesos el acceso a la misma base de datos. </span>Sin embargo, la memoria caché compartida que nos permite seguir en directo entre las operaciones, en lugar de borrarlo después de cada transacción como sqlite no por defecto.</p>
+<div class="almost_half_cell" style="display: block;">
+ <div dir="ltr" style="">
+  <br>
+  <span class="long_text" id="result_box"><span title="If your application uses many small transactons,
+you can get a significant performance improvement by keeping the cache
+live between transactions.">Si su aplicación utiliza muchas transactons pequeña, puede obtener una mejora significativa del rendimiento al mantener el caché en vivo entre las transacciones. </span><span title='This is done by using an extra "dummy" connection to
+the same database (it is important that you use exactly the same
+filename when opening these connections as determined by strcmp).'>Esto se hace mediante el uso de un suplemento "ficticia" la conexión a la misma base de datos (es importante que utilice exactamente el mismo nombre de archivo al abrir estas conexiones según lo determinado por </span></span><code>strcmp</code><span class="long_text" id="result_box"><span title='This is done by using an extra "dummy" connection to
+the same database (it is important that you use exactly the same
+filename when opening these connections as determined by strcmp).'>). </span><span title="The dummy connection keeps a perpetually open transaction which
+locks the cache in memory.">La conexión ficticia mantiene una transacción perpetuamente abierta, que bloquea el caché en la memoria. </span><span title="Since the cache is shared with the main
+connection, the cache never expires.">Dado que el caché es compartida con la conexión principal, el caché nunca expira. </span><br>
+  <br>
+  <span title="The dummy transaction must be one that locks a
+page in memory.">La transacción debe ser un maniquí que bloquea una página en la memoria. </span><span title="A
+simple BEGIN TRANSACTION statement doesn't do this because sqlite does
+the locking lazily.">Una simple instrucción </span></span><code>BEGIN TRANSACTION</code><span class="long_text" id="result_box"><span title="A
+simple BEGIN TRANSACTION statement doesn't do this because sqlite does
+the locking lazily."> no hace esto porque el bloqueo no sqlite perezosamente. </span><span title="Therefore, you must have a statement
+that modifies data.">Por lo tanto, debe tener una declaración que modifica los datos. </span><span title="It might be
+tempting to run a statement on the sqlite_master which contains the
+information on the tables and indices in the database.">Puede ser tentador para ejecutar una declaración sobre la </span></span><code>sqlite_master</code><span class="long_text" id="result_box"><span title="It might be
+tempting to run a statement on the sqlite_master which contains the
+information on the tables and indices in the database."> que contiene la información sobre las tablas e índices en la base de datos. </span><span title="However, if your application is initializing the database for
+the first time, this table will be empty and the cache won't be locked.">Sin embargo, si su aplicación se está inicializando la base de datos por primera vez, esta tabla estará vacía y la caché no estará bloqueado. </span><span title="nsNavHistory::StartDummyStatement creates a dummy table with a
+single element in it for this purpose.">nsNavHistory:: StartDummyStatement crea una tabla de maniquí con un solo elemento en él para este fin. </span><br>
+  <br>
+  <span title="It is important to note that when a statement is
+open, the database schema cannot be modified.">Es importante señalar que cuando una instrucción está abierta, el esquema de base de datos no pueden ser modificados. </span><span title="This means that when the
+dummy transaction is running, you cannot create or modify any tables or
+indices, or vacuum the database.">Esto significa que cuando la operación simulada se está ejecutando, no puede crear o modificar las tablas o índices, o el vacío de la base de datos. </span><span title="You will have to stop the dummy transaction, do the
+schema-modifying operation, and restart it.">Usted tiene que parar la operación simulada, hacer la operación de modificación de esquema, y reiniciarlo.</span></span></div>
+</div>
+<p> </p>
+<p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+<p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+<div class="almost_half_cell" style="">
+ <div dir="ltr" style="">
+  <div id="tts_button" style="display: none;" title="Escuchar
+traducción">
+   &lt;object width="18" height="18" id="tts_flash" data="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>" type="application/x-shockwave-flash"&gt; &lt;param name="movie" value="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>"/&gt; &lt;param name="flashvars" value="sound_name=&amp;amp;sound_name_cb=_TTSSoundFile"/&gt; &lt;param name="wmode" value="transparent"/&gt; &lt;param name="allowScriptAccess" value="always"/&gt;&lt;/object&gt;</div>
+  <p><span class="long_text" id="result_box"><span title="">Escrituras en disco</span></span></p>
+  <p><span class="long_text" id="result_box"><span style="background-color: rgb(255, 255, 255);" title="">Sqlite establece las normas básicas de la teoría ACID base de datos:</span></span></p>
+ </div>
+</div>
+<ul>
+ <li><span class="long_text" id="result_box"><span style="background-color: rgb(255, 255, 255);" title="">Atomicidad: cada transacción es atómica y no puede ser "parcialmente" cometidos.</span></span></li>
+ <li><span class="long_text" id="result_box"><span title="">Consistencia: la base de datos no se corrompe.</span></span></li>
+ <li><span class="long_text" id="result_box"><span title="">Aislamiento: varias transacciones no se afectan entre sí.</span></span></li>
+ <li><span class="long_text" id="result_box"><span style="" title="">Durabilidad: una vez ha pasado por cometer, los datos se garantiza que sea cometido.</span></span></li>
+</ul>
+<p><span class="goog-zippy-collapsed" id="romanspan" style="display: none;"><img alt="" class="buttons square13 zippy-plus" id="romanimg" src="http://www.google.es/images/cleardot.gif"><span id="romantext">Mostrar forma romanizada</span></span></p>
+<div class="almost_half_cell" style="display: block;">
+ <div dir="ltr" style="">
+  <div id="tts_button" style="display: none;" title="Escuchar traducción">
+   &lt;object width="18" height="18" id="tts_flash" data="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>" type="application/x-shockwave-flash"&gt; &lt;param name="movie" value="<a class="external" href="http://www.gstatic.com/translate/sound_player.swf" rel="freelink">http://www.gstatic.com/translate/sound_player.swf</a>"/&gt; &lt;param name="flashvars" value="sound_name=&amp;amp;sound_name_cb=_TTSSoundFile"/&gt; &lt;param name="wmode" value="transparent"/&gt; &lt;param name="allowScriptAccess" value="always"/&gt;&lt;/object&gt;</div>
+  <span class="long_text" id="result_box"><span title="The problem is that these requirements
+make some operations, especially commits, very slow.">El problema es que estos requisitos hacer algunas operaciones, especialmente compromete, muy lento. </span><span title='For each commit, sqlite does two disk syncs
+among many other file operations (see the "Atomic Commit"
+section of http://www.sqlite.org/php2004/slides-all.html for more
+information on how this works).'>Para cada confirmación, sqlite hace dos sincroniza el disco entre muchas otras operaciones de archivo (consulte la sección "commit atómico" de </span></span><a class="external" href="http://www.sqlite.org/php2004/slides-all.html" rel="external nofollow" title="http://www.sqlite.org/php2004/slides-all.html">http://www.sqlite.org/php2004/slides-all.html</a><span class="long_text" id="result_box"><span title='For each commit, sqlite does two disk syncs
+among many other file operations (see the "Atomic Commit"
+section of http://www.sqlite.org/php2004/slides-all.html for more
+information on how this works).'> para obtener más información sobre cómo funciona esto). </span><span title="These disk
+syncs are very slow and limit the speed of a commit to the rotational
+speed of the mechanical disk.">Estos sincroniza el disco son muy lentos y limitan la velocidad de un compromiso a la velocidad de rotación del disco mecánico. </span><br>
+  <br>
+  <span title="Vacuuming and zero-fill">Pasar la aspiradora y cero de relleno </span><br>
+  <br>
+  <span title="Sqlite has a VACUUM command to compress unused
+space from the database.">Sqlite tiene un comando VACUUM para comprimir el espacio no utilizado de la base de datos. </span><span title="Sqlite works like a memory manager or a file system.">Sqlite funciona como un administrador de memoria o un sistema de archivos. </span><span title="When data is deleted, the associated bytes are marked as free but
+are not removed from the file.">Cuando se eliminan datos, los bytes asociados se marcan como libres, pero no se quita del archivo. </span><span title="This means that the file will not shrink,
+and some data may still be visible in the file.">Esto significa que el archivo no se reducirá, y los datos todavía pueden ser visibles en el archivo. </span><span title="The way to work around this is to run the
+VACUUM command to remove this space.">La manera de evitar esto es ejecutar el comando de vacío para eliminar este espacio. </span><br>
+  <br>
+  <span title="Vacuuming is very slow.">Pasar la aspiradora es muy lenta. </span><span title="The vacuum command is essentially the
+same as the command line sqlite3 olddb .dump | sqlite3 newdb; mv newdb
+olddb.">El comando de vacío es esencialmente la misma que la línea de comandos sqlite3 olddb. Volcado </span></span><code>sqlite3 olddb .dump | sqlite3 newdb; mv newdb olddb</code>.<span class="long_text" id="result_box"><span title="On some networked
+drives, vacuuming a 10MB database has been timed at over one minute.">En algunas unidades de red, pasar la aspiradora una base de datos de 10 MB ha sido el tiempo en más de un minuto. </span><span title="Therefore, you should avoid
+vacuuming whenever possible.">Por lo tanto, debe evitar siempre que sea posible pasar la aspiradora. </span><br>
+  <br>
+  <span title="Some items in databases are privacy sensitive,
+such as deleted history items.">Algunos artículos de bases de datos son la privacidad sensibles, como los elementos eliminados de la historia. </span><span title="Users have the
+expectation that deleting items in their history will remove the traces
+of that from the database.">Los usuarios tienen la expectativa de que a borrar los elementos de su historia será eliminar los restos de que a partir de la base de datos. </span><span title="As a
+result, Mozilla enables the SQLITE_SECURE_DELETE preprocessor flag in
+db/sqlite3/src/Makefile.in .">Como resultado, Mozilla permite la bandera preprocesador </span></span><code>SQLITE_SECURE_DELETE</code><span class="long_text" id="result_box"><span title="As a
+result, Mozilla enables the SQLITE_SECURE_DELETE preprocessor flag in
+db/sqlite3/src/Makefile.in ."> en </span></span><span class="lang lang-en"><a class="external" href="http://mxr.mozilla.org/mozilla-central/source/db/sqlite3/src/Makefile.in" rel="external nofollow" title="http://mxr.mozilla.org/mozilla-central/source/db/sqlite3/src/Makefile.in"><code>db/sqlite3/src/Makefile.in</code></a> .</span><span class="long_text" id="result_box"><span title="This flag causes deleted
+items to be filled with 0s on disk.">Esta opción hace que los elementos eliminados para ser llenado con 0s en el disco. </span><span title="This eliminates the need to vacuum except to reclaim disk space,
+and makes many operations much faster.">Esto elimina la necesidad de vacío, excepto para recuperar espacio en disco, y hace que muchas operaciones mucho más rápido. </span><br>
+  <br>
+  <span title="Zero-filling can have significant performance
+overhead in some situations.">Zero-llenado pueden tener sobrecarga de rendimiento significativas en algunas situaciones. </span><span title="For example, the history service used to delete many database
+items at shutdown when expiring old history items.">Por ejemplo, el servicio de la historia usa para eliminar varios elementos de base de datos cuando se apaga cuando expira elementos antiguos de la historia. </span><span title='This operation is not necessarily slow, but writing 0s to disk
+in an "ACI" database is still slow.'>Esta operación no es necesariamente lento, pero 0s escribir en el disco en un "ACI" base de datos todavía son lentos. </span><span title="This made shutdown very
+slow because the AsyncIO thread would block shutdown ( bug 328598).">Esto hizo que cierre muy lento porque el hilo AsyncIO bloquearía apagado (</span></span><span class="lang lang-*"><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=328598" rel="external nofollow" title="https://bugzilla.mozilla.org/show_bug.cgi?id=328598">bug 328598</a></span><span class="long_text" id="result_box"><span title="This made shutdown very
+slow because the AsyncIO thread would block shutdown ( bug 328598).">). </span><span title="Shutdown times of more than 30 seconds were seen.">tiempos de parada de más de 30 segundos fueron vistos. </span><span title="As a result, this bug
+introduced incremental history expiration eliminating the need to write
+many 0s to disk on shutdown.">Como resultado, este error introducido la historia de caducidad incremental eliminando la necesidad de escribir muchas 0s en el disco en el apagado. </span><br>
+  <br>
+  <span title="Unfortunately, this operation cannot be
+controlled on a per-transaction or per-connection basis.">Desafortunadamente, esta operación no puede ser controlado en un esquema por transacción o cada conexión. </span><span title="Some operations will benefit, while others
+will be hurt.">Algunas operaciones se beneficiarán, mientras que otros serán afectados.</span></span></div>
+</div>
+<p> </p>