sqlite3.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Danial Behzadi <dani.behzi@ubuntu.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# arman mohebali <armanmohebali@outlook.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-01 14:41+0330\n"
"PO-Revision-Date: 2026-09-13 17:33+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid ":mod:`!sqlite3` --- DB-API 2.0 interface for SQLite databases"
msgstr ":mod:`!sqlite3` --- رابط DB-API 2.0 برای پایگاه‌های داده SQLite"

msgid "**Source code:** :source:`Lib/sqlite3/`"
msgstr "**کد منبع:** :source:`Lib/sqlite3/`"

msgid "SQLite is a C library that provides a lightweight disk-based database that doesn't require a separate server process and allows accessing the database using a nonstandard variant of the SQL query language. Some applications can use SQLite for internal data storage.  It's also possible to prototype an application using SQLite and then port the code to a larger database such as PostgreSQL or Oracle."
msgstr "SQLite کتابخانه‌ای به زبان C است که پایگاه داده‌ای سبک و مبتنی بر دیسک فراهم می‌کند که به فرایند سرور جداگانه‌ای نیاز ندارد و امکان دسترسی به پایگاه داده را با استفاده از گونه‌ای غیراستاندارد از زبان پرس‌وجوی SQL می‌دهد. برخی برنامه‌ها می‌توانند از SQLite برای ذخیره‌سازی داخلی داده‌ها استفاده کنند. همچنین می‌توان پیش‌نمونه‌ای از یک برنامه را با استفاده از SQLite ساخت و سپس کد را به پایگاه داده‌ی بزرگ‌تری مانند PostgreSQL یا Oracle منتقل کرد."

msgid "The :mod:`!sqlite3` module was written by Gerhard Häring.  It provides an SQL interface compliant with the DB-API 2.0 specification described by :pep:`249`, and requires the third-party `SQLite <https://sqlite.org/>`_ library."
msgstr "ماژول :mod:`!sqlite3` توسط Gerhard Häring نوشته شده است. این ماژول یک رابط SQL سازگار با مشخصات DB-API 2.0 ارائه می‌کند که در :pep:`249` توصیف شده است، و به کتابخانه‌ی شخص ثالث `SQLite <https://sqlite.org/>`_ نیاز دارد."

msgid "This is an :term:`optional module`. If it is missing from your copy of CPython, look for documentation from your distributor (that is, whoever provided Python to you). If you are the distributor, see :ref:`optional-module-requirements`."
msgstr "این یک :term:`ماژول اختیاری <optional module>` است. اگر در نسخه CPython شما وجود ندارد، برای مستندات به توزیع‌کننده خود مراجعه کنید (یعنی هر کسی که پایتون را در اختیار شما قرار داده است). اگر شما توزیع‌کننده هستید، :ref:`optional-module-requirements` را ببینید."

msgid "This document includes four main sections:"
msgstr "این سند شامل چهار بخش اصلی است:"

msgid ":ref:`sqlite3-tutorial` teaches how to use the :mod:`!sqlite3` module."
msgstr ":ref:`sqlite3-tutorial` چگونگی استفاده از ماژول :mod:`!sqlite3` را آموزش می‌دهد."

msgid ":ref:`sqlite3-reference` describes the classes and functions this module defines."
msgstr ":ref:`sqlite3-reference` کلاس‌ها و توابعی را که این ماژول تعریف می‌کند، شرح می‌دهد."

msgid ":ref:`sqlite3-howtos` details how to handle specific tasks."
msgstr ":ref:`sqlite3-howtos` جزئیات چگونگی انجام وظایف خاص را شرح می‌دهد."

msgid ":ref:`sqlite3-explanation` provides in-depth background on transaction control."
msgstr ":ref:`sqlite3-explanation` پیش‌زمینه‌ای عمیق درباره‌ی کنترل تراکنش ارائه می‌دهد."

msgid "https://www.sqlite.org"
msgstr "https://www.sqlite.org"

msgid "The SQLite web page; the documentation describes the syntax and the available data types for the supported SQL dialect."
msgstr "صفحه‌ی وب SQLite؛ مستندات، سینتکس و انواع داده‌های موجود برای گویش SQL پشتیبانی‌شده را توضیح می‌دهد."

msgid "https://www.w3schools.com/sql/"
msgstr "https://www.w3schools.com/sql/"

msgid "Tutorial, reference and examples for learning SQL syntax."
msgstr "آموزش، مرجع و مثال‌هایی برای یادگیری سینتکس SQL."

msgid ":pep:`249` - Database API Specification 2.0"
msgstr ":pep:`249` - مشخصات API پایگاه داده 2.0"

msgid "PEP written by Marc-André Lemburg."
msgstr "PEP نوشته‌شده توسط Marc-André Lemburg."

msgid "Tutorial"
msgstr "آموزش"

msgid "In this tutorial, you will create a database of Monty Python movies using basic :mod:`!sqlite3` functionality. It assumes a fundamental understanding of database concepts, including `cursors`_ and `transactions`_."
msgstr "در این آموزش، شما پایگاه داده‌ای از فیلم‌های مانتی پایتون را با استفاده از قابلیت‌های پایه :mod:`!sqlite3` ایجاد خواهید کرد. این آموزش فرض می‌کند که شما درک بنیادی از مفاهیم پایگاه داده، از جمله `cursors`_ و `transactions`_ دارید."

msgid "First, we need to create a new database and open a database connection to allow :mod:`!sqlite3` to work with it. Call :func:`sqlite3.connect` to create a connection to the database :file:`tutorial.db` in the current working directory, implicitly creating it if it does not exist:"
msgstr "نخست، باید یک پایگاه داده جدید ایجاد کنیم و یک اتصال به پایگاه داده باز کنیم تا :mod:`!sqlite3` بتواند با آن کار کند. برای ایجاد اتصال به پایگاه داده‌ی :file:`tutorial.db` در پوشه کاری فعلی، :func:`sqlite3.connect` را فراخوانی کنید؛ اگر این پایگاه داده وجود نداشته باشد، به‌طور ضمنی ایجاد می‌شود:"

msgid ""
"import sqlite3\n"
"con = sqlite3.connect(\"tutorial.db\")"
msgstr ""
"import sqlite3\n"
"con = sqlite3.connect(\"tutorial.db\")"

msgid "The returned :class:`Connection` object ``con`` represents the connection to the on-disk database."
msgstr "شیء :class:`Connection` بازگردانده‌شده ``con``، نشان‌دهنده‌ی اتصال به پایگاه داده‌ی روی دیسک است."

msgid "In order to execute SQL statements and fetch results from SQL queries, we will need to use a database cursor. Call :meth:`con.cursor() <Connection.cursor>` to create the :class:`Cursor`:"
msgstr "برای اجرای دستورات SQL و واکشی نتایج از پرس‌وجوهای SQL، باید از یک نشانگر پایگاه داده استفاده کنیم. برای ایجاد :class:`Cursor`، :meth:`con.cursor() <Connection.cursor>` را فراخوانی کنید:"

msgid "cur = con.cursor()"
msgstr "cur = con.cursor()"

msgid "Now that we've got a database connection and a cursor, we can create a database table ``movie`` with columns for title, release year, and review score. For simplicity, we can just use column names in the table declaration -- thanks to the `flexible typing`_ feature of SQLite, specifying the data types is optional. Execute the ``CREATE TABLE`` statement by calling :meth:`cur.execute(...) <Cursor.execute>`:"
msgstr "اکنون که یک اتصال به پایگاه داده و یک نشانگر داریم، می‌توانیم یک جدول پایگاه داده به نام ``movie`` با ستون‌هایی برای عنوان، سال انتشار و امتیاز نقد ایجاد کنیم. برای سادگی، می‌توانیم فقط از نام ستون‌ها در تعریف جدول استفاده کنیم — به‌لطف قابلیت `flexible typing`_ در SQLite، تعیین نوع‌های داده اختیاری است. دستور ``CREATE TABLE`` را با فراخوانی :meth:`cur.execute(...) <Cursor.execute>` اجرا کنید:"

msgid "cur.execute(\"CREATE TABLE movie(title, year, score)\")"
msgstr "cur.execute(\"CREATE TABLE movie(title, year, score)\")"

msgid "We can verify that the new table has been created by querying the ``sqlite_master`` table built-in to SQLite, which should now contain an entry for the ``movie`` table definition (see `The Schema Table`_ for details). Execute that query by calling :meth:`cur.execute(...) <Cursor.execute>`, assign the result to ``res``, and call :meth:`res.fetchone() <Cursor.fetchone>` to fetch the resulting row:"
msgstr "می‌توانیم با پرس‌وجوی جدول ``sqlite_master`` توکار در SQLite، تأیید کنیم که جدول جدید ایجاد شده است؛ این جدول اکنون باید شامل ورودی‌ای برای تعریف جدول ``movie`` باشد (برای جزئیات `The Schema Table`_ را ببینید). آن پرس‌وجو را با فراخوانی :meth:`cur.execute(...) <Cursor.execute>` اجرا کنید، نتیجه را به ``res`` اختصاص دهید و برای واکشی ردیف حاصل :meth:`res.fetchone() <Cursor.fetchone>` را فراخوانی کنید:"

msgid ""
">>> res = cur.execute(\"SELECT name FROM sqlite_master\")\n"
">>> res.fetchone()\n"
"('movie',)"
msgstr ""
">>> res = cur.execute(\"SELECT name FROM sqlite_master\")\n"
">>> res.fetchone()\n"
"('movie',)"

msgid "We can see that the table has been created, as the query returns a :class:`tuple` containing the table's name. If we query ``sqlite_master`` for a non-existent table ``spam``, :meth:`!res.fetchone` will return ``None``:"
msgstr "می‌توانیم ببینیم که جدول ایجاد شده است، زیرا پرس‌وجو یک :class:`tuple` برمی‌گرداند که شامل نام جدول است. اگر ``sqlite_master`` را برای جدولی به نام ``spam`` که وجود ندارد پرس‌وجو کنیم، :meth:`!res.fetchone` ``None`` را برمی‌گرداند:"

msgid ""
">>> res = cur.execute(\"SELECT name FROM sqlite_master WHERE name='spam'\")\n"
">>> res.fetchone() is None\n"
"True"
msgstr ""
">>> res = cur.execute(\"SELECT name FROM sqlite_master WHERE name='spam'\")\n"
">>> res.fetchone() is None\n"
"True"

msgid "Now, add two rows of data supplied as SQL literals by executing an ``INSERT`` statement, once again by calling :meth:`cur.execute(...) <Cursor.execute>`:"
msgstr "اکنون، با اجرای یک دستور ``INSERT``، دو ردیف داده را که به‌صورت مقادیر لفظی SQL ارائه شده‌اند، بار دیگر با فراخوانی :meth:`cur.execute(...) <Cursor.execute>` اضافه کنید:"

msgid ""
"cur.execute(\"\"\"\n"
"    INSERT INTO movie VALUES\n"
"        ('Monty Python and the Holy Grail', 1975, 8.2),\n"
"        ('And Now for Something Completely Different', 1971, 7.5)\n"
"\"\"\")"
msgstr ""
"cur.execute(\"\"\"\n"
"    INSERT INTO movie VALUES\n"
"        ('Monty Python and the Holy Grail', 1975, 8.2),\n"
"        ('And Now for Something Completely Different', 1971, 7.5)\n"
"\"\"\")"

msgid "The ``INSERT`` statement implicitly opens a transaction, which needs to be committed before changes are saved in the database (see :ref:`sqlite3-controlling-transactions` for details). Call :meth:`con.commit() <Connection.commit>` on the connection object to commit the transaction:"
msgstr "دستور ``INSERT`` به‌طور ضمنی یک تراکنش را باز می‌کند، که باید پیش از ذخیره شدن تغییرات در پایگاه داده، ثبت (commit) شود (برای جزئیات :ref:`sqlite3-controlling-transactions` را ببینید). برای ثبت تراکنش، :meth:`con.commit() <Connection.commit>` را روی شیء اتصال فراخوانی کنید:"

msgid "con.commit()"
msgstr "con.commit()"

msgid "We can verify that the data was inserted correctly by executing a ``SELECT`` query. Use the now-familiar :meth:`cur.execute(...) <Cursor.execute>` to assign the result to ``res``, and call :meth:`res.fetchall() <Cursor.fetchall>` to return all resulting rows:"
msgstr "می‌توانیم با اجرای یک پرس‌وجوی ``SELECT`` تأیید کنیم که داده‌ها به‌درستی درج شده‌اند. از :meth:`cur.execute(...) <Cursor.execute>` که اکنون برایتان آشناست، برای اختصاص نتیجه به ``res`` استفاده کنید و :meth:`res.fetchall() <Cursor.fetchall>` را فراخوانی کنید تا تمام ردیف‌های حاصل را برگرداند:"

msgid ""
">>> res = cur.execute(\"SELECT score FROM movie\")\n"
">>> res.fetchall()\n"
"[(8.2,), (7.5,)]"
msgstr ""
">>> res = cur.execute(\"SELECT score FROM movie\")\n"
">>> res.fetchall()\n"
"[(8.2,), (7.5,)]"

msgid "The result is a :class:`list` of two :class:`!tuple`\\s, one per row, each containing that row's ``score`` value."
msgstr "نتیجه یک :class:`list` شامل دو :class:`!tuple` است، یکی به‌ازای هر ردیف، که هر یک حاوی مقدار ``score`` آن ردیف است."

msgid "Now, insert three more rows by calling :meth:`cur.executemany(...) <Cursor.executemany>`:"
msgstr "اکنون، ۳ ردیف دیگر را با فراخوانی :meth:`cur.executemany(...) <Cursor.executemany>` درج کنید:"

msgid ""
"data = [\n"
"    (\"Monty Python Live at the Hollywood Bowl\", 1982, 7.9),\n"
"    (\"Monty Python's The Meaning of Life\", 1983, 7.5),\n"
"    (\"Monty Python's Life of Brian\", 1979, 8.0),\n"
"]\n"
"cur.executemany(\"INSERT INTO movie VALUES(?, ?, ?)\", data)\n"
"con.commit()  # Remember to commit the transaction after executing INSERT."
msgstr ""
"data = [\n"
"    (\"Monty Python Live at the Hollywood Bowl\", 1982, 7.9),\n"
"    (\"Monty Python's The Meaning of Life\", 1983, 7.5),\n"
"    (\"Monty Python's Life of Brian\", 1979, 8.0),\n"
"]\n"
"cur.executemany(\"INSERT INTO movie VALUES(?, ?, ?)\", data)\n"
"con.commit()  # Remember to commit the transaction after executing INSERT."

msgid "Notice that ``?`` placeholders are used to bind ``data`` to the query. Always use placeholders instead of :ref:`string formatting <tut-formatting>` to bind Python values to SQL statements, to avoid `SQL injection attacks`_ (see :ref:`sqlite3-placeholders` for more details)."
msgstr "توجه داشته باشید که از جای‌نگهدارهای ``?`` برای مقید کردن ``data`` به پرس‌وجو استفاده می‌شود. همیشه برای مقید کردن مقادیر پایتون به دستورهای SQL، به‌جای :ref:`قالب‌بندی رشته <tut-formatting>` از جای‌نگهدارها استفاده کنید تا از `SQL injection attacks`_ جلوگیری شود (برای جزئیات بیشتر :ref:`sqlite3-placeholders` را ببینید)."

msgid "We can verify that the new rows were inserted by executing a ``SELECT`` query, this time iterating over the results of the query:"
msgstr "می‌توانیم با اجرای یک پرس‌وجوی ``SELECT`` تأیید کنیم که ردیف‌های جدید درج شده‌اند؛ این بار با پیمایش روی نتایج پرس‌وجو:"

msgid ""
">>> for row in cur.execute(\"SELECT year, title FROM movie ORDER BY year\"):\n"
"...     print(row)\n"
"(1971, 'And Now for Something Completely Different')\n"
"(1975, 'Monty Python and the Holy Grail')\n"
"(1979, \"Monty Python's Life of Brian\")\n"
"(1982, 'Monty Python Live at the Hollywood Bowl')\n"
"(1983, \"Monty Python's The Meaning of Life\")"
msgstr ""
">>> for row in cur.execute(\"SELECT year, title FROM movie ORDER BY year\"):\n"
"...     print(row)\n"
"(1971, 'And Now for Something Completely Different')\n"
"(1975, 'Monty Python and the Holy Grail')\n"
"(1979, \"Monty Python's Life of Brian\")\n"
"(1982, 'Monty Python Live at the Hollywood Bowl')\n"
"(1983, \"Monty Python's The Meaning of Life\")"

msgid "Each row is a two-item :class:`tuple` of ``(year, title)``, matching the columns selected in the query."
msgstr "هر ردیف یک :class:`tuple` دو آیتمی از ``(year, title)`` است که با ستون‌های انتخاب‌شده در پرس‌وجو مطابقت دارد."

msgid "Finally, verify that the database has been written to disk by calling :meth:`con.close() <Connection.close>` to close the existing connection, opening a new one, creating a new cursor, then querying the database:"
msgstr "در نهایت، با فراخوانی :meth:`con.close() <Connection.close>` برای بستن اتصال موجود، باز کردن یک اتصال جدید، ایجاد یک نشانگر جدید و سپس پرس‌وجو از پایگاه داده، تأیید کنید که پایگاه داده روی دیسک نوشته شده است:"

msgid ""
">>> con.close()\n"
">>> new_con = sqlite3.connect(\"tutorial.db\")\n"
">>> new_cur = new_con.cursor()\n"
">>> res = new_cur.execute(\"SELECT title, year FROM movie ORDER BY score DESC\")\n"
">>> title, year = res.fetchone()\n"
">>> print(f'The highest scoring Monty Python movie is {title!r}, released in {year}')\n"
"The highest scoring Monty Python movie is 'Monty Python and the Holy Grail', released in 1975\n"
">>> new_con.close()"
msgstr ""
">>> con.close()\n"
">>> new_con = sqlite3.connect(\"tutorial.db\")\n"
">>> new_cur = new_con.cursor()\n"
">>> res = new_cur.execute(\"SELECT title, year FROM movie ORDER BY score DESC\")\n"
">>> title, year = res.fetchone()\n"
">>> print(f'The highest scoring Monty Python movie is {title!r}, released in {year}')\n"
"The highest scoring Monty Python movie is 'Monty Python and the Holy Grail', released in 1975\n"
">>> new_con.close()"

msgid "You've now created an SQLite database using the :mod:`!sqlite3` module, inserted data and retrieved values from it in multiple ways."
msgstr "اکنون با استفاده از ماژول :mod:`!sqlite3` یک پایگاه داده SQLite ایجاد کرده‌اید، داده‌ها را درج کرده‌اید و مقادیر را به روش‌های متعدد از آن بازیابی کرده‌اید."

msgid ":ref:`sqlite3-howtos` for further reading:"
msgstr ":ref:`sqlite3-howtos` برای مطالعه بیشتر:"

msgid ":ref:`sqlite3-placeholders`"
msgstr ":ref:`sqlite3-placeholders`"

msgid ":ref:`sqlite3-adapters`"
msgstr ":ref:`sqlite3-adapters`"

msgid ":ref:`sqlite3-converters`"
msgstr ":ref:`sqlite3-converters`"

msgid ":ref:`sqlite3-connection-context-manager`"
msgstr ":ref:`sqlite3-connection-context-manager`"

msgid ":ref:`sqlite3-howto-row-factory`"
msgstr ":ref:`sqlite3-howto-row-factory`"

msgid ":ref:`sqlite3-explanation` for in-depth background on transaction control."
msgstr ":ref:`sqlite3-explanation` برای پیش‌زمینه‌ی تفصیلی درباره‌ی کنترل تراکنش."

msgid "Reference"
msgstr "مرجع"

msgid "Module functions"
msgstr "توابع ماژول"

msgid "Open a connection to an SQLite database."
msgstr "باز کردن اتصال به یک پایگاه داده‌ی SQLite."

msgid "Parameters"
msgstr "پارامترها"

msgid "The path to the database file to be opened. You can pass ``\":memory:\"`` to create an `SQLite database existing only in memory <https://sqlite.org/inmemorydb.html>`_, and open a connection to it."
msgstr "مسیر پرونده پایگاه داده‌ای که باید باز شود. می‌توانید ``\":memory:\"`` را برای ایجاد یک `پایگاه داده SQLite که فقط در حافظه وجود دارد <https://sqlite.org/inmemorydb.html>`_ و باز کردن اتصالی به آن ارسال کنید."

msgid "How many seconds the connection should wait before raising an :exc:`OperationalError` when a table is locked. If another connection opens a transaction to modify a table, that table will be locked until the transaction is committed. Default five seconds."
msgstr "تعداد ثانیه‌هایی که اتصال باید هنگام قفل بودن یک جدول، پیش از پرتاب :exc:`OperationalError` منتظر بماند. اگر اتصال دیگری تراکنشی را برای تغییر یک جدول آغاز کند، آن جدول تا زمانی که تراکنش ثبت نهایی (commit) شود، قفل خواهد بود. پیش‌فرض پنج ثانیه است."

msgid "Control whether and how data types not :ref:`natively supported by SQLite <sqlite3-types>` are looked up to be converted to Python types, using the converters registered with :func:`register_converter`. Set it to any combination (using ``|``, bitwise or) of :const:`PARSE_DECLTYPES` and :const:`PARSE_COLNAMES` to enable this. Column names take precedence over declared types if both flags are set. By default (``0``), type detection is disabled."
msgstr "کنترل کنید که آیا و چگونه انواع داده‌ای که :ref:`به‌صورت بومی توسط SQLite پشتیبانی نمی‌شوند <sqlite3-types>`، جستجو می‌شوند تا با استفاده از مبدل‌های ثبت‌شده با :func:`register_converter` به نوع‌های پایتون تبدیل شوند. برای فعال‌سازی این مورد، آن را روی هر ترکیبی از :const:`PARSE_DECLTYPES` و :const:`PARSE_COLNAMES` (با استفاده از ``|``، یای بیتی) تنظیم کنید. اگر هر دو پرچم تنظیم شده باشند، نام ستون‌ها بر نوع‌های اعلام‌شده اولویت دارند. به‌طور پیش‌فرض (``0``)، تشخیص نوع غیرفعال است."

msgid "Control legacy transaction handling behaviour. See :attr:`Connection.isolation_level` and :ref:`sqlite3-transaction-control-isolation-level` for more information. Can be ``\"DEFERRED\"`` (default), ``\"EXCLUSIVE\"`` or ``\"IMMEDIATE\"``; or ``None`` to disable opening transactions implicitly. Has no effect unless :attr:`Connection.autocommit` is set to :const:`~sqlite3.LEGACY_TRANSACTION_CONTROL` (the default)."
msgstr "رفتار مدیریت تراکنش‌ها به روش قدیمی را کنترل می‌کند. برای اطلاعات بیشتر :attr:`Connection.isolation_level` و :ref:`sqlite3-transaction-control-isolation-level` را ببینید. می‌تواند ``\"DEFERRED\"`` (پیش‌فرض)، ``\"EXCLUSIVE\"`` یا ``\"IMMEDIATE\"`` باشد؛ یا برای غیرفعال کردن باز شدن تراکنش‌ها به‌صورت ضمنی، ``None`` باشد. هیچ تأثیری ندارد مگر اینکه :attr:`Connection.autocommit` روی :const:`~sqlite3.LEGACY_TRANSACTION_CONTROL` (پیش‌فرض) تنظیم شده باشد."

msgid "If ``True`` (default), :exc:`ProgrammingError` will be raised if the database connection is used by a thread other than the one that created it. If ``False``, the connection may be accessed in multiple threads; write operations may need to be serialized by the user to avoid data corruption. See :attr:`threadsafety` for more information."
msgstr "اگر ``True`` (پیش‌فرض) باشد، در صورتی که از اتصال پایگاه داده در نخی غیر از نخی که آن را ایجاد کرده است استفاده شود، :exc:`ProgrammingError` پرتاب می‌شود. اگر ``False`` باشد، ممکن است اتصال در چندین نخ مورد دسترسی قرار گیرد؛ ممکن است لازم باشد کاربر برای جلوگیری از خرابی داده‌ها، عملیات نوشتن را به‌صورت متوالی اجرا کند. برای اطلاعات بیشتر :attr:`threadsafety` را ببینید."

msgid "A custom subclass of :class:`Connection` to create the connection with, if not the default :class:`Connection` class."
msgstr "یک زیرکلاس سفارشی از :class:`Connection` برای ایجاد اتصال با آن، اگر کلاس پیش‌فرض :class:`Connection` نباشد."

msgid "The number of statements that :mod:`!sqlite3` should internally cache for this connection, to avoid parsing overhead. By default, 128 statements."
msgstr "تعداد دستورهایی که :mod:`!sqlite3` باید برای این اتصال به‌صورت داخلی در نهانگاه ذخیره کند، تا از سربار تجزیه جلوگیری شود. به‌طور پیش‌فرض، ۱۲۸ دستور."

msgid "If set to ``True``, *database* is interpreted as a :abbr:`URI (Uniform Resource Identifier)` with a file path and an optional query string. The scheme part *must* be ``\"file:\"``, and the path can be relative or absolute. The query string allows passing parameters to SQLite, enabling various :ref:`sqlite3-uri-tricks`."
msgstr "اگر روی ``True`` تنظیم شود، *database* به‌عنوان یک :abbr:`URI (Uniform Resource Identifier)` با یک مسیر پرونده و یک رشته‌ی پرس‌وجوی اختیاری تفسیر می‌شود. بخش طرح‌واره  *باید* ``\"file:\"`` باشد، و مسیر می‌تواند نسبی یا مطلق باشد. رشته‌ی پرس‌وجو امکان ارسال پارامترها به SQLite را فراهم می‌کند و ترفندهای گوناگون :ref:`sqlite3-uri-tricks` را ممکن می‌سازد."

msgid "Control :pep:`249` transaction handling behaviour. See :attr:`Connection.autocommit` and :ref:`sqlite3-transaction-control-autocommit` for more information. *autocommit* currently defaults to :const:`~sqlite3.LEGACY_TRANSACTION_CONTROL`. The default will change to ``False`` in a future Python release."
msgstr "رفتار مدیریت تراکنش :pep:`249` را کنترل می‌کند. برای اطلاعات بیشتر، :attr:`Connection.autocommit` و :ref:`sqlite3-transaction-control-autocommit` را ببینید. مقدار پیش‌فرض *autocommit* در حال حاضر :const:`~sqlite3.LEGACY_TRANSACTION_CONTROL` است. این مقدار پیش‌فرض در یکی از نسخه‌های آینده پایتون به ``False`` تغییر خواهد کرد."

msgid "Return type"
msgstr "نوع بازگشتی"

msgid "Raises an :ref:`auditing event <auditing>` ``sqlite3.connect`` with argument ``database``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` ``sqlite3.connect`` را با آرگومان ``database`` پرتاب می‌کند."

msgid "Raises an :ref:`auditing event <auditing>` ``sqlite3.connect/handle`` with argument ``connection_handle``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` ``sqlite3.connect/handle`` را با آرگومان ``connection_handle`` پرتاب می‌کند."

msgid "Added the *uri* parameter."
msgstr "پارامتر *uri* اضافه شد."

msgid "*database* can now also be a :term:`path-like object`, not only a string."
msgstr "*database* اکنون می‌تواند یک :term:`path-like object` نیز باشد، نه فقط یک رشته."

msgid "Added the ``sqlite3.connect/handle`` auditing event."
msgstr "رویداد حسابرسی ``sqlite3.connect/handle`` افزوده شد."

msgid "Added the *autocommit* parameter."
msgstr "پارامتر *autocommit* افزوده شد."

msgid "All parameters except *database* are now keyword-only."
msgstr "اکنون تمام پارامترها به جز *database* فقط کلیدواژه‌ای هستند."

msgid "Return ``True`` if the string *statement* appears to contain one or more complete SQL statements. No syntactic verification or parsing of any kind is performed, other than checking that there are no unclosed string literals and the statement is terminated by a semicolon."
msgstr "اگر به نظر برسد که رشته‌ی *statement* حاوی یک یا چند دستور کامل SQL باشد، ``True`` را برمی‌گرداند. هیچ‌گونه صحت‌سنجی سینتکسی یا تجزیه‌ای از هیچ نوع انجام نمی‌شود، به‌جز بررسی اینکه هیچ لفظی رشته‌ای بسته‌نشده‌ای وجود نداشته باشد و دستور با نقطه‌ویرگول پایان یافته باشد."

msgid "For example:"
msgstr "برای مثال:"

msgid ""
">>> sqlite3.complete_statement(\"SELECT foo FROM bar;\")\n"
"True\n"
">>> sqlite3.complete_statement(\"SELECT foo\")\n"
"False"
msgstr ""
">>> sqlite3.complete_statement(\"SELECT foo FROM bar;\")\n"
"True\n"
">>> sqlite3.complete_statement(\"SELECT foo\")\n"
"False"

msgid "This function may be useful during command-line input to determine if the entered text seems to form a complete SQL statement, or if additional input is needed before calling :meth:`~Cursor.execute`."
msgstr "این تابع ممکن است در حین ورودی از خط فرمان برای تشخیص این‌که آیا به نظر می‌رسد متن واردشده یک دستور SQL کامل را تشکیل می‌دهد، یا پیش از فراخوانی :meth:`~Cursor.execute` به ورودی بیشتری نیاز است، مفید باشد."

msgid "See :func:`!runsource` in :source:`Lib/sqlite3/__main__.py` for real-world use."
msgstr "برای استفاده در دنیای واقعی، :func:`!runsource` را در :source:`Lib/sqlite3/__main__.py` ببینید."

msgid "Enable or disable callback tracebacks. By default you will not get any tracebacks in user-defined functions, aggregates, converters, authorizer callbacks etc. If you want to debug them, you can call this function with *flag* set to ``True``. Afterwards, you will get tracebacks from callbacks on :data:`sys.stderr`. Use ``False`` to disable the feature again."
msgstr "فعال یا غیرفعال کردن ردگیری‌های پشته‌ی کال‌بک‌ها. به‌طور پیش‌فرض، هیچ ردگیری پشته‌ای در توابع تعریف‌شده توسط کاربر، تجمیع‌ها، مبدل‌ها، کال‌بک‌های مجوزدهنده و غیره دریافت نخواهید کرد. اگر می‌خواهید آن‌ها را اشکال‌زدایی کنید، می‌توانید این تابع را با *flag* برابر ``True`` فراخوانی کنید. پس از آن، ردگیری‌های پشته‌ی کال‌بک‌ها را در :data:`sys.stderr` دریافت خواهید کرد. برای غیرفعال کردن مجدد این قابلیت، از ``False`` استفاده کنید."

msgid "Errors in user-defined function callbacks are logged as unraisable exceptions. Use an :func:`unraisable hook handler <sys.unraisablehook>` for introspection of the failed callback."
msgstr "خطاهای کال‌بک‌های تابعی تعریف‌شده توسط کاربر به‌عنوان استثناهای غیرقابل‌پرتاب ثبت می‌شوند. برای درون‌نگری کال‌بک ناموفق، از یک :func:`unraisable hook handler <sys.unraisablehook>` استفاده کنید."

msgid "Register an *adapter* :term:`callable` to adapt the Python type *type* into an SQLite type. The adapter is called with a Python object of type *type* as its sole argument, and must return a value of a :ref:`type that SQLite natively understands <sqlite3-types>`."
msgstr "یک *adapter* :term:`callable` برای تبدیل نوع پایتون *type* به یک نوع SQLite ثبت کنید. این آداپتور با یک شیء پایتون از نوع *type* به‌عنوان تنها آرگومان خود فراخوانی می‌شود و باید مقداری از :ref:`نوعی که SQLite به‌صورت بومی آن را می‌شناسد <sqlite3-types>` برگرداند."

msgid "Register the *converter* :term:`callable` to convert SQLite objects of type *typename* into a Python object of a specific type. The converter is invoked for all SQLite values of type *typename*; it is passed a :class:`bytes` object and should return an object of the desired Python type. Consult the parameter *detect_types* of :func:`connect` for information regarding how type detection works."
msgstr "برای تبدیل اشیای SQLite از نوع *typename* به یک شیء پایتون از نوع مشخص، *converter* :term:`callable` را ثبت کنید. مبدل برای همه مقادیر SQLite از نوع *typename* فراخوانی می‌شود؛ یک شیء :class:`bytes` به آن داده می‌شود و باید یک شیء از نوع پایتون دلخواه را برگرداند. برای آگاهی از چگونگی کارکرد تشخیص نوع، به پارامتر *detect_types* در :func:`connect` مراجعه کنید."

msgid "Note: *typename* and the name of the type in your query are matched case-insensitively."
msgstr "توجه: *typename* و نام نوع در پرس‌وجوی شما، بدون حساسیت به بزرگی و کوچکی حروف تطبیق داده می‌شوند."

msgid "Module constants"
msgstr "ثابت‌های ماژول"

msgid "Set :attr:`~Connection.autocommit` to this constant to select old style (pre-Python 3.12) transaction control behaviour. See :ref:`sqlite3-transaction-control-isolation-level` for more information."
msgstr "برای انتخاب رفتار کنترل تراکنش به سبک قدیمی (پیش از Python 3.12)، :attr:`~Connection.autocommit` را روی این ثابت تنظیم کنید. برای اطلاعات بیشتر :ref:`sqlite3-transaction-control-isolation-level` را ببینید."

msgid "Pass this flag value to the *detect_types* parameter of :func:`connect` to look up a converter function using the declared types for each column. The types are declared when the database table is created. :mod:`!sqlite3` will look up a converter function using the first word of the declared type as the converter dictionary key. For example:"
msgstr "مقدار این پرچم را به پارامتر *detect_types* در :func:`connect` بدهید تا با استفاده از انواع اعلام‌شده برای هر ستون، یک تابع تبدیل‌کننده جست‌وجو شود. این انواع هنگام ایجاد جدول پایگاه داده اعلام می‌شوند. :mod:`!sqlite3` یک تابع تبدیل‌کننده را با استفاده از نخستین واژه‌ی نوع اعلام‌شده به‌عنوان کلید دیکشنری مبدل جست‌وجو می‌کند. برای مثال:"

msgid ""
"CREATE TABLE test(\n"
"   i integer primary key,  ! will look up a converter named \"integer\"\n"
"   p point,                ! will look up a converter named \"point\"\n"
"   n number(10)            ! will look up a converter named \"number\"\n"
" )"
msgstr ""
"CREATE TABLE test(\n"
"   i integer primary key,  ! will look up a converter named \"integer\"\n"
"   p point,                ! will look up a converter named \"point\"\n"
"   n number(10)            ! will look up a converter named \"number\"\n"
" )"

msgid "This flag may be combined with :const:`PARSE_COLNAMES` using the ``|`` (bitwise or) operator."
msgstr "این پرچم را می‌توان با استفاده از عملگر ``|`` (یا بیت‌به‌بیت) با :const:`PARSE_COLNAMES` ترکیب کرد."

msgid "Generated fields (for example ``MAX(p)``) are returned as :class:`str`. Use :const:`!PARSE_COLNAMES` to enforce types for such queries."
msgstr "فیلدهای تولیدشده (برای مثال ``MAX(p)``) به‌صورت :class:`str` برگردانده می‌شوند. برای اعمال نوع‌ها در چنین پرس‌وجوهایی از :const:`!PARSE_COLNAMES` استفاده کنید."

msgid "Pass this flag value to the *detect_types* parameter of :func:`connect` to look up a converter function by using the type name, parsed from the query column name, as the converter dictionary key. The query column name must be wrapped in double quotes (``\"``) and the type name must be wrapped in square brackets (``[]``)."
msgstr "این مقدار پرچم را به پارامتر *detect_types* از :func:`connect` بدهید تا با استفاده از نام نوع، که از نام ستون پرس‌وجو تجزیه می‌شود، به‌عنوان کلید دیکشنری مبدل، یک تابع مبدل را جستجو کنید. نام ستون پرس‌وجو باید داخل علامت نقل‌قول دوتایی (``\"``) و نام نوع باید داخل کروشه (``[]``) قرار گیرد."

msgid "SELECT MAX(p) as \"p [point]\" FROM test;  ! will look up converter \"point\""
msgstr "SELECT MAX(p) as \"p [point]\" FROM test;  ! will look up converter \"point\""

msgid "This flag may be combined with :const:`PARSE_DECLTYPES` using the ``|`` (bitwise or) operator."
msgstr "می‌توان این پرچم را با :const:`PARSE_DECLTYPES` با استفاده از عملگر ``|`` (یای بیتی) ترکیب کرد."

msgid "Flags that should be returned by the *authorizer_callback* :term:`callable` passed to :meth:`Connection.set_authorizer`, to indicate whether:"
msgstr "پرچم‌هایی که باید توسط *authorizer_callback* :term:`callable` ارسال‌شده به :meth:`Connection.set_authorizer` بازگردانده شوند، تا نشان دهند که آیا:"

msgid "Access is allowed (:const:`!SQLITE_OK`),"
msgstr "دسترسی مجاز است (:const:`!SQLITE_OK`)،"

msgid "The SQL statement should be aborted with an error (:const:`!SQLITE_DENY`)"
msgstr "دستور SQL باید با یک خطا متوقف شود (:const:`!SQLITE_DENY`)"

msgid "The column should be treated as a ``NULL`` value (:const:`!SQLITE_IGNORE`)"
msgstr "این ستون باید به‌عنوان یک مقدار ``NULL`` در نظر گرفته شود (:const:`!SQLITE_IGNORE`)"

msgid "String constant stating the supported DB-API level. Required by the DB-API. Hard-coded to ``\"2.0\"``."
msgstr "ثابت رشته‌ای که سطح DB-API پشتیبانی‌شده را اعلام می‌کند. مورد نیاز DB-API است. به‌صورت سخت‌کد (hard-coded) برابر با ``\"2.0\"`` است."

msgid "String constant stating the type of parameter marker formatting expected by the :mod:`!sqlite3` module. Required by the DB-API. Hard-coded to ``\"qmark\"``."
msgstr "ثابت رشته‌ای که نوع قالب‌بندی نشانگر پارامتر مورد انتظار ماژول :mod:`!sqlite3` را مشخص می‌کند. این ثابت توسط DB-API الزامی شده و به‌صورت سخت‌کد به ``\"qmark\"`` تنظیم شده است."

msgid "The ``named`` DB-API parameter style is also supported."
msgstr "سبک پارامتر ``named`` در DB-API نیز پشتیبانی می‌شود."

msgid "Version number of the runtime SQLite library as a :class:`string <str>`."
msgstr "شماره‌ی نسخه‌ی کتابخانه‌ی SQLite ران‌تایم به‌صورت یک :class:`string <str>`."

msgid "Version number of the runtime SQLite library as a :class:`tuple` of :class:`integers <int>`."
msgstr "شماره نسخه کتابخانه SQLite در ران‌تایم به‌صورت یک :class:`tuple` از :class:`اعداد صحیح <int>`."

msgid "A :class:`tuple` containing all SQLite keywords."
msgstr "یک :class:`tuple` حاوی تمام کلیدواژه‌های SQLite."

msgid "This constant is only available if Python was compiled with SQLite 3.24.0 or greater."
msgstr "این ثابت فقط در صورتی در دسترس است که پایتون با SQLite 3.24.0 یا بالاتر کامپایل‌شده باشد."

msgid "Integer constant required by the DB-API 2.0, stating the level of thread safety the :mod:`!sqlite3` module supports. This attribute is set based on the default `threading mode <https://sqlite.org/threadsafe.html>`_ the underlying SQLite library is compiled with. The SQLite threading modes are:"
msgstr "ثابت عدد صحیح مورد نیاز DB-API 2.0، که سطح ایمنی نخی را که ماژول :mod:`!sqlite3` پشتیبانی می‌کند، مشخص می‌کند. این ویژگی بر اساس `حالت نخی (threading mode) <https://sqlite.org/threadsafe.html>`_ پیش‌فرضی تنظیم می‌شود که کتابخانه زیربنایی SQLite با آن کامپایل شده است. حالت‌های نخی SQLite عبارتند از:"

msgid "**Single-thread**: In this mode, all mutexes are disabled and SQLite is unsafe to use in more than a single thread at once."
msgstr "**تک‌نخی**: در این حالت، همه قفل‌های متقابل غیرفعال هستند و استفاده از SQLite در بیش از یک نخ به‌طور همزمان ایمن نیست."

msgid "**Multi-thread**: In this mode, SQLite can be safely used by multiple threads provided that no single database connection is used simultaneously in two or more threads."
msgstr "**چندنخی**: در این حالت، می‌توان از SQLite به‌طور امن در چندین نخ استفاده کرد، مشروط بر اینکه هیچ اتصال پایگاه داده‌ای به‌طور همزمان در دو یا چند نخ استفاده نشود."

msgid "**Serialized**: In serialized mode, SQLite can be safely used by multiple threads with no restriction."
msgstr "**سریال‌شده**: در حالت سریال‌شده، می‌توان از SQLite به‌صورت ایمن توسط چندین نخ بدون هیچ‌گونه محدودیتی استفاده کرد."

msgid "The mappings from SQLite threading modes to DB-API 2.0 threadsafety levels are as follows:"
msgstr "نگاشت حالت‌های نخی SQLite به سطوح ایمنی نخی DB-API 2.0 به شرح زیر است:"

msgid "SQLite threading mode"
msgstr "حالت نخ‌بندی SQLite"

msgid ":pep:`threadsafety <0249#threadsafety>`"
msgstr ":pep:`threadsafety <0249#threadsafety>`"

msgid "`SQLITE_THREADSAFE`_"
msgstr "`SQLITE_THREADSAFE`_"

msgid "DB-API 2.0 meaning"
msgstr "معنای DB-API 2.0"

msgid "single-thread"
msgstr "تک‌نخی"

msgid "0"
msgstr "0"

msgid "Threads may not share the module"
msgstr "نخ‌ها نمی‌توانند ماژول را به اشتراک بگذارند"

msgid "multi-thread"
msgstr "چندنخی"

msgid "1"
msgstr "1"

msgid "2"
msgstr "۲"

msgid "Threads may share the module, but not connections"
msgstr "نخ‌ها می‌توانند ماژول را به اشتراک بگذارند، اما اتصال‌ها را نه"

msgid "serialized"
msgstr "سریال‌شده"

msgid "3"
msgstr "۳"

msgid "Threads may share the module, connections and cursors"
msgstr "نخ‌ها می‌توانند ماژول، اتصال‌ها و نشانگرها را به اشتراک بگذارند"

msgid "Set *threadsafety* dynamically instead of hard-coding it to ``1``."
msgstr "به‌جای سخت‌کد کردن آن روی ``1``، *threadsafety* را به‌صورت پویا تنظیم کنید."

msgid "These constants are used for the :meth:`Connection.setconfig` and :meth:`~Connection.getconfig` methods."
msgstr "این ثابت‌ها برای متدهای :meth:`Connection.setconfig` و :meth:`~Connection.getconfig` استفاده می‌شوند."

msgid "The availability of these constants varies depending on the version of SQLite Python was compiled with."
msgstr "دسترس‌پذیری این ثابت‌ها بسته به نسخه‌ی SQLite که پایتون با آن کامپایل شده است، متفاوت است."

msgid "https://www.sqlite.org/c3ref/c_dbconfig_defensive.html"
msgstr "https://www.sqlite.org/c3ref/c_dbconfig_defensive.html"

msgid "SQLite docs: Database Connection Configuration Options"
msgstr "مستندات SQLite: گزینه‌های پیکربندی اتصال پایگاه داده"

msgid "The :data:`!version` and :data:`!version_info` constants."
msgstr "ثابت‌های :data:`!version` و :data:`!version_info`."

msgid "Connection objects"
msgstr "اشیای اتصال"

msgid "Each open SQLite database is represented by a ``Connection`` object, which is created using :func:`sqlite3.connect`. Their main purpose is creating :class:`Cursor` objects, and :ref:`sqlite3-controlling-transactions`."
msgstr "هر پایگاه داده‌ی باز SQLite با یک شیء ``Connection`` نمایش داده می‌شود، که با استفاده از :func:`sqlite3.connect` ایجاد می‌شود. هدف اصلی آن‌ها ایجاد اشیای :class:`Cursor` و :ref:`sqlite3-controlling-transactions` است."

msgid ":ref:`sqlite3-connection-shortcuts`"
msgstr ":ref:`sqlite3-connection-shortcuts`"

msgid "A :exc:`ResourceWarning` is emitted if :meth:`close` is not called before a :class:`!Connection` object is deleted."
msgstr "اگر :meth:`close` پیش از حذف یک شیء :class:`!Connection` فراخوانی نشود، یک :exc:`ResourceWarning` نشان داده می‌شود."

msgid "An SQLite database connection has the following attributes and methods:"
msgstr "اتصال پایگاه داده‌ی SQLite دارای ویژگی‌ها و متدهای زیر است:"

msgid "Create and return a :class:`Cursor` object. The cursor method accepts a single optional parameter *factory*. If supplied, this must be a :term:`callable` returning an instance of :class:`Cursor` or its subclasses."
msgstr "یک شیء :class:`Cursor` را ایجاد کرده و برمی‌گرداند. متد cursor یک پارامتر اختیاری واحد به نام *factory* می‌پذیرد. در صورت ارائه، این باید یک :term:`callable` باشد که نمونه‌ای از :class:`Cursor` یا زیرکلاس‌های آن را برمی‌گرداند."

msgid "Open a :class:`Blob` handle to an existing :abbr:`BLOB (Binary Large OBject)`."
msgstr "یک دسته‌ی :class:`Blob` به یک :abbr:`BLOB (Binary Large OBject)` موجود باز کنید."

msgid "The name of the table where the blob is located."
msgstr "نام جدولی که blob در آن قرار دارد."

msgid "The name of the column where the blob is located."
msgstr "نام ستونی که blob در آن قرار دارد."

msgid "The row id where the blob is located."
msgstr "شناسه‌ی ردیفی که blob در آن قرار دارد."

msgid "Set to ``True`` if the blob should be opened without write permissions. Defaults to ``False``."
msgstr "اگر قرار باشد blob بدون اجازه‌های نوشتن باز شود، روی ``True`` تنظیم شود. پیش‌فرض آن ``False`` است."

msgid "The name of the database where the blob is located. Defaults to ``\"main\"``."
msgstr "نام پایگاه داده‌ای که بلاب (blob) در آن قرار دارد. به‌طور پیش‌فرض ``\"main\"`` است."

msgid "Raises"
msgstr "پرتاب می‌کند"

msgid "When trying to open a blob in a ``WITHOUT ROWID`` table."
msgstr "هنگام تلاش برای باز کردن یک بلاب در جدول ``WITHOUT ROWID``."

msgid "The blob size cannot be changed using the :class:`Blob` class. Use the SQL function ``zeroblob`` to create a blob with a fixed size."
msgstr "اندازه‌ی blob را نمی‌توان با استفاده از کلاس :class:`Blob` تغییر داد. برای ایجاد یک blob با اندازه‌ی ثابت، از تابع SQL ``zeroblob`` استفاده کنید."

msgid "Commit any pending transaction to the database. If :attr:`autocommit` is ``True``, or there is no open transaction, this method does nothing. If :attr:`!autocommit` is ``False``, a new transaction is implicitly opened if a pending transaction was committed by this method."
msgstr "هر تراکنش در انتظار را در پایگاه داده ثبت می‌کند. اگر :attr:`autocommit` برابر ``True`` باشد، یا هیچ تراکنش بازی وجود نداشته باشد، این متد هیچ کاری انجام نمی‌دهد. اگر :attr:`!autocommit` برابر ``False`` باشد، چنانچه تراکنش در انتظاری توسط این متد ثبت شود، تراکنش جدیدی به‌طور ضمنی باز می‌شود."

msgid "Roll back to the start of any pending transaction. If :attr:`autocommit` is ``True``, or there is no open transaction, this method does nothing. If :attr:`!autocommit` is ``False``, a new transaction is implicitly opened if a pending transaction was rolled back by this method."
msgstr "به آغاز هر تراکنش در حال انتظار عقب‌گرد می‌کند. اگر :attr:`autocommit` برابر ``True`` باشد، یا هیچ تراکنش بازی وجود نداشته باشد، این متد هیچ کاری انجام نمی‌دهد. اگر :attr:`!autocommit` برابر ``False`` باشد، در صورتی که یک تراکنش در حال انتظار توسط این متد عقب‌گرد شده باشد، تراکنش جدیدی به‌طور ضمنی باز می‌شود."

msgid "Close the database connection. If :attr:`autocommit` is ``False``, any pending transaction is implicitly rolled back. If :attr:`!autocommit` is ``True`` or :data:`LEGACY_TRANSACTION_CONTROL`, no implicit transaction control is executed. Make sure to :meth:`commit` before closing to avoid losing pending changes."
msgstr "اتصال به پایگاه داده را ببندید. اگر :attr:`autocommit` برابر ``False`` باشد، هر تراکنش در انتظاری به‌صورت ضمنی بازگردانده می‌شود. اگر :attr:`!autocommit` برابر ``True`` یا :data:`LEGACY_TRANSACTION_CONTROL` باشد، هیچ کنترل تراکنشی به‌صورت ضمنی اعمال نمی‌شود. برای جلوگیری از دست رفتن تغییرات در انتظار، اطمینان حاصل کنید که پیش از بستن، :meth:`commit` را فراخوانی کنید."

msgid "Create a new :class:`Cursor` object and call :meth:`~Cursor.execute` on it with the given *sql* and *parameters*. Return the new cursor object."
msgstr "یک شیء :class:`Cursor` جدید ایجاد می‌کند و :meth:`~Cursor.execute` را با *sql* و *parameters* داده‌شده روی آن فراخوانی می‌کند. شیء نشانگر جدید را برمی‌گرداند."

msgid "Create a new :class:`Cursor` object and call :meth:`~Cursor.executemany` on it with the given *sql* and *parameters*. Return the new cursor object."
msgstr "یک شیء :class:`Cursor` جدید ایجاد کنید و :meth:`~Cursor.executemany` را با *sql* و *parameters* داده‌شده روی آن فراخوانی کنید. شیء نشانگر جدید را برگردانید."

msgid "Create a new :class:`Cursor` object and call :meth:`~Cursor.executescript` on it with the given *sql_script*. Return the new cursor object."
msgstr "یک شیء :class:`Cursor` جدید ایجاد می‌کند و :meth:`~Cursor.executescript` را با *sql_script* داده‌شده روی آن فراخوانی می‌کند. شیء نشانگر جدید را برمی‌گرداند."

msgid "Create or remove a user-defined SQL function."
msgstr "ایجاد یا حذف یک تابع SQL تعریف‌شده توسط کاربر."

msgid "The name of the SQL function."
msgstr "نام تابع SQL."

msgid "The number of arguments the SQL function can accept. If ``-1``, it may take any number of arguments."
msgstr "تعداد آرگومان‌هایی که تابع SQL می‌تواند بپذیرد. اگر ``-1`` باشد، می‌تواند هر تعداد آرگومان بگیرد."

msgid "A :term:`callable` that is called when the SQL function is invoked. The callable must return :ref:`a type natively supported by SQLite <sqlite3-types>`. Set to ``None`` to remove an existing SQL function."
msgstr "یک :term:`فراخوانی‌پذیر <callable>` است که هنگام فراخوانی تابع SQL فراخوانده می‌شود. این فراخوانی‌پذیر باید :ref:`نوعی که SQLite به‌صورت بومی از آن پشتیبانی می‌کند <sqlite3-types>` را برگرداند. برای حذف یک تابع SQL موجود، آن را روی ``None`` تنظیم کنید."

msgid "If ``True``, the created SQL function is marked as `deterministic <https://sqlite.org/deterministic.html>`_, which allows SQLite to perform additional optimizations."
msgstr "اگر ``True`` باشد، تابع SQL ایجادشده به‌عنوان `قطعی (deterministic) <https://sqlite.org/deterministic.html>`_ علامت‌گذاری می‌شود، که به SQLite امکان می‌دهد بهینه‌سازی‌های بیشتری انجام دهد."

msgid "Added the *deterministic* parameter."
msgstr "پارامتر *deterministic* افزوده شد."

msgid "The first three parameters are now positional-only."
msgstr "سه پارامتر اول اکنون فقط جایگاهی هستند."

msgid "Example:"
msgstr "مثال:"

msgid ""
">>> import hashlib\n"
">>> def md5sum(t):\n"
"...     return hashlib.md5(t).hexdigest()\n"
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.create_function(\"md5\", 1, md5sum)\n"
">>> for row in con.execute(\"SELECT md5(?)\", (b\"foo\",)):\n"
"...     print(row)\n"
"('acbd18db4cc2f85cedef654fccc4a4d8',)\n"
">>> con.close()"
msgstr ""
">>> import hashlib\n"
">>> def md5sum(t):\n"
"...     return hashlib.md5(t).hexdigest()\n"
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.create_function(\"md5\", 1, md5sum)\n"
">>> for row in con.execute(\"SELECT md5(?)\", (b\"foo\",)):\n"
"...     print(row)\n"
"('acbd18db4cc2f85cedef654fccc4a4d8',)\n"
">>> con.close()"

msgid "Create or remove a user-defined SQL aggregate function."
msgstr "ایجاد یا حذف یک تابع تجمیعی SQL تعریف‌شده توسط کاربر."

msgid "The name of the SQL aggregate function."
msgstr "نام تابع تجمعی SQL."

msgid "The number of arguments the SQL aggregate function can accept. If ``-1``, it may take any number of arguments."
msgstr "تعداد آرگومان‌هایی که تابع تجمیعی SQL می‌تواند بپذیرد. اگر ``-1`` باشد، ممکن است هر تعداد آرگومان را بپذیرد."

msgid "A class must implement the following methods:  * ``step()``: Add a row to the aggregate. * ``finalize()``: Return the final result of the aggregate as   :ref:`a type natively supported by SQLite <sqlite3-types>`.  The number of arguments that the ``step()`` method must accept is controlled by *n_arg*.  Set to ``None`` to remove an existing SQL aggregate function."
msgstr "یک کلاس باید متدهای زیر را پیاده‌سازی کند:  * ``step()``: یک ردیف را به تجمیع اضافه می‌کند. * ``finalize()``: نتیجه نهایی تجمیع را به‌عنوان :ref:`نوعی که به‌صورت بومی توسط SQLite پشتیبانی می‌شود <sqlite3-types>` برمی‌گرداند.  تعداد آرگومان‌هایی که متد ``step()`` باید بپذیرد، با *n_arg* کنترل می‌شود.  برای حذف یک تابع تجمیعی SQL موجود، آن را روی ``None`` تنظیم کنید."

msgid "A class must implement the following methods:"
msgstr "یک کلاس باید متدهای زیر را پیاده‌سازی کند:"

msgid "``step()``: Add a row to the aggregate."
msgstr "``step()``: یک ردیف به تجمیع اضافه می‌کند."

msgid "``finalize()``: Return the final result of the aggregate as :ref:`a type natively supported by SQLite <sqlite3-types>`."
msgstr "``finalize()``: نتیجه نهایی تجمیع را به‌عنوان :ref:`نوعی که به‌صورت بومی توسط SQLite پشتیبانی می‌شود <sqlite3-types>` برمی‌گرداند."

msgid "The number of arguments that the ``step()`` method must accept is controlled by *n_arg*."
msgstr "تعداد آرگومان‌هایی که متد ``step()`` باید بپذیرد، توسط *n_arg* کنترل می‌شود."

msgid "Set to ``None`` to remove an existing SQL aggregate function."
msgstr "برای حذف یک تابع تجمیعی SQL موجود، آن را روی ``None`` تنظیم کنید."

msgid "All three parameters are now positional-only."
msgstr "هر سه پارامتر اکنون فقط جایگاهی هستند."

msgid ""
"class MySum:\n"
"    def __init__(self):\n"
"        self.count = 0\n"
"\n"
"    def step(self, value):\n"
"        self.count += value\n"
"\n"
"    def finalize(self):\n"
"        return self.count\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"con.create_aggregate(\"mysum\", 1, MySum)\n"
"cur = con.execute(\"CREATE TABLE test(i)\")\n"
"cur.execute(\"INSERT INTO test(i) VALUES(1)\")\n"
"cur.execute(\"INSERT INTO test(i) VALUES(2)\")\n"
"cur.execute(\"SELECT mysum(i) FROM test\")\n"
"print(cur.fetchone()[0])\n"
"\n"
"con.close()"
msgstr ""
"class MySum:\n"
"    def __init__(self):\n"
"        self.count = 0\n"
"\n"
"    def step(self, value):\n"
"        self.count += value\n"
"\n"
"    def finalize(self):\n"
"        return self.count\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"con.create_aggregate(\"mysum\", 1, MySum)\n"
"cur = con.execute(\"CREATE TABLE test(i)\")\n"
"cur.execute(\"INSERT INTO test(i) VALUES(1)\")\n"
"cur.execute(\"INSERT INTO test(i) VALUES(2)\")\n"
"cur.execute(\"SELECT mysum(i) FROM test\")\n"
"print(cur.fetchone()[0])\n"
"\n"
"con.close()"

msgid "Create or remove a user-defined aggregate window function."
msgstr "ایجاد یا حذف یک تابع پنجره‌ای تجمیعی تعریف‌شده توسط کاربر."

msgid "The name of the SQL aggregate window function to create or remove."
msgstr "نام تابع پنجره‌ای تجمیعی SQL برای ایجاد یا حذف."

msgid "The number of arguments the SQL aggregate window function can accept. If ``-1``, it may take any number of arguments."
msgstr "تعداد آرگومان‌هایی که تابع تجمیعی پنجره‌ای SQL می‌تواند بپذیرد. اگر ``-1`` باشد، می‌تواند هر تعداد آرگومان بگیرد."

msgid "A class that must implement the following methods:  * ``step()``: Add a row to the current window. * ``value()``: Return the current value of the aggregate. * ``inverse()``: Remove a row from the current window. * ``finalize()``: Return the final result of the aggregate as   :ref:`a type natively supported by SQLite <sqlite3-types>`.  The number of arguments that the ``step()`` and ``value()`` methods must accept is controlled by *num_params*.  Set to ``None`` to remove an existing SQL aggregate window function."
msgstr "کلاسی که باید متدهای زیر را پیاده‌سازی کند:  * ``step()``: افزودن یک ردیف به پنجره جاری. * ``value()``: برگرداندن مقدار فعلی تجمیع. * ``inverse()``: حذف یک ردیف از پنجره جاری. * ``finalize()``: برگرداندن نتیجه نهایی تجمیع به‌عنوان :ref:`نوعی که SQLite به‌صورت بومی از آن پشتیبانی می‌کند <sqlite3-types>`.  تعداد آرگومان‌هایی که متدهای ``step()`` و ``value()`` باید بپذیرند، با *num_params* کنترل می‌شود.  برای حذف یک تابع پنجره‌ای تجمیعی SQL موجود، آن را روی ``None`` تنظیم کنید."

msgid "A class that must implement the following methods:"
msgstr "کلاسی که باید متدهای زیر را پیاده‌سازی کند:"

msgid "``step()``: Add a row to the current window."
msgstr "``step()``: یک ردیف به پنجره‌ی جاری اضافه می‌کند."

msgid "``value()``: Return the current value of the aggregate."
msgstr "``value()``: مقدار جاری تجمعی (aggregate) را برمی‌گرداند."

msgid "``inverse()``: Remove a row from the current window."
msgstr "``inverse()``: یک ردیف را از پنجره‌ی جاری حذف می‌کند."

msgid "The number of arguments that the ``step()`` and ``value()`` methods must accept is controlled by *num_params*."
msgstr "تعداد آرگومان‌هایی که متدهای ``step()`` و ``value()`` باید بپذیرند، توسط *num_params* کنترل می‌شود."

msgid "Set to ``None`` to remove an existing SQL aggregate window function."
msgstr "برای حذف یک تابع پنجره‌ای تجمیعی SQL موجود، آن را روی ``None`` تنظیم کنید."

msgid "If used with a version of SQLite older than 3.25.0, which does not support aggregate window functions."
msgstr "اگر با نسخه‌ای از SQLite قدیمی‌تر از 3.25.0 استفاده شود، که از توابع پنجره‌ای تجمیعی پشتیبانی نمی‌کند."

msgid ""
"# Example taken from https://www.sqlite.org/windowfunctions.html#udfwinfunc\n"
"class WindowSumInt:\n"
"    def __init__(self):\n"
"        self.count = 0\n"
"\n"
"    def step(self, value):\n"
"        \"\"\"Add a row to the current window.\"\"\"\n"
"        self.count += value\n"
"\n"
"    def value(self):\n"
"        \"\"\"Return the current value of the aggregate.\"\"\"\n"
"        return self.count\n"
"\n"
"    def inverse(self, value):\n"
"        \"\"\"Remove a row from the current window.\"\"\"\n"
"        self.count -= value\n"
"\n"
"    def finalize(self):\n"
"        \"\"\"Return the final value of the aggregate.\n"
"\n"
"        Any clean-up actions should be placed here.\n"
"        \"\"\"\n"
"        return self.count\n"
"\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.execute(\"CREATE TABLE test(x, y)\")\n"
"values = [\n"
"    (\"a\", 4),\n"
"    (\"b\", 5),\n"
"    (\"c\", 3),\n"
"    (\"d\", 8),\n"
"    (\"e\", 1),\n"
"]\n"
"cur.executemany(\"INSERT INTO test VALUES(?, ?)\", values)\n"
"con.create_window_function(\"sumint\", 1, WindowSumInt)\n"
"cur.execute(\"\"\"\n"
"    SELECT x, sumint(y) OVER (\n"
"        ORDER BY x ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING\n"
"    ) AS sum_y\n"
"    FROM test ORDER BY x\n"
"\"\"\")\n"
"print(cur.fetchall())\n"
"con.close()"
msgstr ""
"# Example taken from https://www.sqlite.org/windowfunctions.html#udfwinfunc\n"
"class WindowSumInt:\n"
"    def __init__(self):\n"
"        self.count = 0\n"
"\n"
"    def step(self, value):\n"
"        \"\"\"Add a row to the current window.\"\"\"\n"
"        self.count += value\n"
"\n"
"    def value(self):\n"
"        \"\"\"Return the current value of the aggregate.\"\"\"\n"
"        return self.count\n"
"\n"
"    def inverse(self, value):\n"
"        \"\"\"Remove a row from the current window.\"\"\"\n"
"        self.count -= value\n"
"\n"
"    def finalize(self):\n"
"        \"\"\"Return the final value of the aggregate.\n"
"\n"
"        Any clean-up actions should be placed here.\n"
"        \"\"\"\n"
"        return self.count\n"
"\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.execute(\"CREATE TABLE test(x, y)\")\n"
"values = [\n"
"    (\"a\", 4),\n"
"    (\"b\", 5),\n"
"    (\"c\", 3),\n"
"    (\"d\", 8),\n"
"    (\"e\", 1),\n"
"]\n"
"cur.executemany(\"INSERT INTO test VALUES(?, ?)\", values)\n"
"con.create_window_function(\"sumint\", 1, WindowSumInt)\n"
"cur.execute(\"\"\"\n"
"    SELECT x, sumint(y) OVER (\n"
"        ORDER BY x ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING\n"
"    ) AS sum_y\n"
"    FROM test ORDER BY x\n"
"\"\"\")\n"
"print(cur.fetchall())\n"
"con.close()"

msgid "Create a collation named *name* using the collating function *callable*. *callable* is passed two :class:`string <str>` arguments, and it should return an :class:`integer <int>`:"
msgstr "یک ترتیب‌گذاری (collation) به نام *name* با استفاده از تابع مقایسه‌کننده *callable* ایجاد کنید. *callable* دو آرگومان از نوع :class:`رشته <str>` دریافت می‌کند و باید یک :class:`عدد صحیح <int>` برگرداند:"

msgid "``1`` if the first is ordered higher than the second"
msgstr "``1`` اگر مورد اول بالاتر از مورد دوم مرتب شده باشد"

msgid "``-1`` if the first is ordered lower than the second"
msgstr "``-1`` اگر اولی از نظر ترتیب، پایین‌تر از دومی باشد"

msgid "``0`` if they are ordered equal"
msgstr "``0`` اگر از نظر ترتیب برابر باشند"

msgid "The following example shows a reverse sorting collation:"
msgstr "مثال زیر یک ترتیب‌گذاری (collation) مرتب‌سازی معکوس را نشان می‌دهد:"

msgid ""
"def collate_reverse(string1, string2):\n"
"    if string1 == string2:\n"
"        return 0\n"
"    elif string1 < string2:\n"
"        return 1\n"
"    else:\n"
"        return -1\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"con.create_collation(\"reverse\", collate_reverse)\n"
"\n"
"cur = con.execute(\"CREATE TABLE test(x)\")\n"
"cur.executemany(\"INSERT INTO test(x) VALUES(?)\", [(\"a\",), (\"b\",)])\n"
"cur.execute(\"SELECT x FROM test ORDER BY x COLLATE reverse\")\n"
"for row in cur:\n"
"    print(row)\n"
"con.close()"
msgstr ""
"def collate_reverse(string1, string2):\n"
"    if string1 == string2:\n"
"        return 0\n"
"    elif string1 < string2:\n"
"        return 1\n"
"    else:\n"
"        return -1\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"con.create_collation(\"reverse\", collate_reverse)\n"
"\n"
"cur = con.execute(\"CREATE TABLE test(x)\")\n"
"cur.executemany(\"INSERT INTO test(x) VALUES(?)\", [(\"a\",), (\"b\",)])\n"
"cur.execute(\"SELECT x FROM test ORDER BY x COLLATE reverse\")\n"
"for row in cur:\n"
"    print(row)\n"
"con.close()"

msgid "Remove a collation function by setting *callable* to ``None``."
msgstr "برای حذف یک تابع ترتیب‌گذاری (collation)، *callable* را روی ``None`` تنظیم کنید."

msgid "The collation name can contain any Unicode character.  Earlier, only ASCII characters were allowed."
msgstr "نام ترتیب‌گذاری (collation) می‌تواند شامل هر نویسه‌ای از Unicode باشد. پیش‌تر، فقط نویسه‌های ASCII مجاز بودند."

msgid "Call this method from a different thread to abort any queries that might be executing on the connection. Aborted queries will raise an :exc:`OperationalError`."
msgstr "این متد را از یک نخ دیگر فراخوانی کنید تا هر پرس‌وجویی که ممکن است روی اتصال در حال اجرا باشد، لغو شود. پرس‌وجوهای لغوشده یک :exc:`OperationalError` پرتاب خواهند کرد."

msgid "Register :term:`callable` *authorizer_callback* to be invoked for each attempt to access a column of a table in the database. The callback should return one of :const:`SQLITE_OK`, :const:`SQLITE_DENY`, or :const:`SQLITE_IGNORE` to signal how access to the column should be handled by the underlying SQLite library."
msgstr "*authorizer_callback*، یک :term:`فراخوانی‌پذیر <callable>`، را ثبت کنید تا برای هر تلاش برای دسترسی به یک ستون از یک جدول در پایگاه داده فراخوانی شود. این کال‌بک باید یکی از :const:`SQLITE_OK`، :const:`SQLITE_DENY` یا :const:`SQLITE_IGNORE` را برگرداند تا مشخص کند دسترسی به ستون باید توسط کتابخانه زیربنایی SQLite چگونه مدیریت شود."

msgid "The first argument to the callback signifies what kind of operation is to be authorized. The second and third argument will be arguments or ``None`` depending on the first argument. The 4th argument is the name of the database (\"main\", \"temp\", etc.) if applicable. The 5th argument is the name of the inner-most trigger or view that is responsible for the access attempt or ``None`` if this access attempt is directly from input SQL code."
msgstr "نخستین آرگومان کال‌بک نشان می‌دهد که چه نوع عملیاتی باید مجاز شود. آرگومان دوم و سوم، بسته به آرگومان نخست، یا آرگومان‌هایی خواهند بود یا ``None``. آرگومان چهارم در صورت لزوم، نام پایگاه داده (\"main\"، \"temp\" و غیره) است. آرگومان پنجم نام درونی‌ترین تریگر یا ویویی است که مسئول تلاش برای دسترسی است، یا ``None`` اگر این تلاش برای دسترسی مستقیماً از کد SQL ورودی باشد."

msgid "Please consult the SQLite documentation about the possible values for the first argument and the meaning of the second and third argument depending on the first one. All necessary constants are available in the :mod:`!sqlite3` module."
msgstr "لطفاً مستندات SQLite را درباره‌ی مقادیر ممکن برای آرگومان اول و معنی آرگومان دوم و سوم، بسته به آرگومان اول، ببینید. همه‌ی ثابت‌های مورد نیاز در ماژول :mod:`!sqlite3` در دسترس هستند."

msgid "Passing ``None`` as *authorizer_callback* will disable the authorizer."
msgstr "با ارسال ``None`` به‌عنوان *authorizer_callback*، تأییدکننده‌ی دسترسی غیرفعال می‌شود."

msgid "Added support for disabling the authorizer using ``None``."
msgstr "پشتیبانی از غیرفعال‌سازی مجوزدهنده (authorizer) با استفاده از ``None`` افزوده شد."

msgid "The only parameter is now positional-only."
msgstr "تنها پارامتر اکنون فقط جایگاهی است."

msgid "Register :term:`callable` *progress_handler* to be invoked for every *n* instructions of the SQLite virtual machine. This is useful if you want to get called from SQLite during long-running operations, for example to update a GUI."
msgstr ":term:`callable` *progress_handler* را ثبت کنید تا به ازای هر *n* دستورالعملِ ماشین مجازی SQLite فراخوانی شود. این قابلیت زمانی مفید است که بخواهید در حین عملیات‌های طولانی‌مدت از SQLite فراخوانی شوید، برای مثال برای به‌روزرسانی رابط کاربری گرافیکی (GUI)."

msgid "If you want to clear any previously installed progress handler, call the method with ``None`` for *progress_handler*."
msgstr "اگر می‌خواهید هر مدیر پیشرفت (progress handler) نصب‌شده‌ی قبلی را پاک کنید، متد را با ``None`` برای *progress_handler* فراخوانی کنید."

msgid "Returning a non-zero value from the handler function will terminate the currently executing query and cause it to raise a :exc:`DatabaseError` exception."
msgstr "بازگرداندن یک مقدار غیرصفر از تابع هندلر، پرس‌وجوی در حال اجرا را خاتمه می‌دهد و باعث می‌شود که یک استثنا :exc:`DatabaseError` پرتاب شود."

msgid "The first parameter is now positional-only."
msgstr "پارامتر اول اکنون فقط جایگاهی است."

msgid "Register :term:`callable` *trace_callback* to be invoked for each SQL statement that is actually executed by the SQLite backend."
msgstr "یک :term:`callable` به نام *trace_callback* را ثبت کنید تا برای هر دستور SQL که به‌طور واقعی توسط بک‌اند SQLite اجرا می‌شود، فراخوانی شود."

msgid "The only argument passed to the callback is the statement (as :class:`str`) that is being executed. The return value of the callback is ignored. Note that the backend does not only run statements passed to the :meth:`Cursor.execute` methods.  Other sources include the :ref:`transaction management <sqlite3-controlling-transactions>` of the :mod:`!sqlite3` module and the execution of triggers defined in the current database."
msgstr "تنها آرگومانی که به کال‌بک داده می‌شود، دستور در حال اجرا (به‌صورت :class:`str`) است. مقدار بازگشتی کال‌بک نادیده گرفته می‌شود. توجه داشته باشید که بک‌اند تنها دستورهایی را که به متدهای :meth:`Cursor.execute` داده‌شده‌اند، اجرا نمی‌کند. منابع دیگر شامل :ref:`مدیریت تراکنش <sqlite3-controlling-transactions>` ماژول :mod:`!sqlite3` و اجرای ماشه‌های تعریف‌شده در پایگاه داده‌ی جاری هستند."

msgid "Passing ``None`` as *trace_callback* will disable the trace callback."
msgstr "با ارسال ``None`` به‌عنوان *trace_callback*، کال‌بک ردگیری غیرفعال می‌شود."

msgid "Exceptions raised in the trace callback are not propagated. As a development and debugging aid, use :meth:`~sqlite3.enable_callback_tracebacks` to enable printing tracebacks from exceptions raised in the trace callback."
msgstr "استثناهای پرتاب‌شده در کال‌بک ردگیری منتشر نمی‌شوند. به‌عنوان کمکی برای توسعه و اشکال‌زدایی، از :meth:`~sqlite3.enable_callback_tracebacks` برای فعال کردن چاپ ردگیری‌های پشته‌ی استثناهای پرتاب‌شده در کال‌بک ردگیری استفاده کنید."

msgid "Enable the SQLite engine to load SQLite extensions from shared libraries if *enabled* is ``True``; else, disallow loading SQLite extensions. SQLite extensions can define new functions, aggregates or whole new virtual table implementations.  One well-known extension is the fulltext-search extension distributed with SQLite."
msgstr "اگر *enabled* برابر ``True`` باشد، به موتور SQLite اجازه می‌دهد تا افزونه‌های SQLite را از کتابخانه‌های مشترک بارگذاری کند؛ در غیر این صورت، بارگذاری افزونه‌های SQLite را مجاز نمی‌داند. افزونه‌های SQLite می‌توانند توابع جدید، تجمیع‌ها یا پیاده‌سازی‌های کاملاً جدید جدول مجازی را تعریف کنند. یکی از افزونه‌های شناخته‌شده، افزونه جستجوی تمام‌متنی (fulltext-search) است که همراه SQLite توزیع شده است."

msgid "The :mod:`!sqlite3` module is not built with loadable extension support by default, because some platforms (notably macOS) have SQLite libraries which are compiled without this feature. To get loadable extension support, you must pass the :option:`--enable-loadable-sqlite-extensions` option to :program:`configure`."
msgstr "ماژول :mod:`!sqlite3` به‌طور پیش‌فرض با پشتیبانی از افزونه‌های قابل بارگذاری ساخته نمی‌شود، زیرا برخی سکوها (به‌ویژه macOS) کتابخانه‌های SQLite دارند که بدون این قابلیت کامپایل شده‌اند. برای بهره‌مندی از پشتیبانی از افزونه‌های قابل بارگذاری، باید گزینه‌ی :option:`--enable-loadable-sqlite-extensions` را به :program:`configure` بدهید."

msgid "Raises an :ref:`auditing event <auditing>` ``sqlite3.enable_load_extension`` with arguments ``connection``, ``enabled``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` ``sqlite3.enable_load_extension`` را با آرگومان‌های ``connection`` و ``enabled`` پرتاب می‌کند."

msgid "Added the ``sqlite3.enable_load_extension`` auditing event."
msgstr "رویداد حسابرسی ``sqlite3.enable_load_extension`` اضافه شد."

msgid ""
"con.enable_load_extension(True)\n"
"\n"
"# Load the fulltext search extension\n"
"con.execute(\"select load_extension('./fts3.so')\")\n"
"\n"
"# alternatively you can load the extension using an API call:\n"
"# con.load_extension(\"./fts3.so\")\n"
"\n"
"# disable extension loading again\n"
"con.enable_load_extension(False)\n"
"\n"
"# example from SQLite wiki\n"
"con.execute(\"CREATE VIRTUAL TABLE recipe USING fts3(name, ingredients)\")\n"
"con.executescript(\"\"\"\n"
"    INSERT INTO recipe (name, ingredients) VALUES('broccoli stew', 'broccoli peppers cheese tomatoes');\n"
"    INSERT INTO recipe (name, ingredients) VALUES('pumpkin stew', 'pumpkin onions garlic celery');\n"
"    INSERT INTO recipe (name, ingredients) VALUES('broccoli pie', 'broccoli cheese onions flour');\n"
"    INSERT INTO recipe (name, ingredients) VALUES('pumpkin pie', 'pumpkin sugar flour butter');\n"
"    \"\"\")\n"
"for row in con.execute(\"SELECT rowid, name, ingredients FROM recipe WHERE name MATCH 'pie'\"):\n"
"    print(row)"
msgstr ""
"con.enable_load_extension(True)\n"
"\n"
"# Load the fulltext search extension\n"
"con.execute(\"select load_extension('./fts3.so')\")\n"
"\n"
"# alternatively you can load the extension using an API call:\n"
"# con.load_extension(\"./fts3.so\")\n"
"\n"
"# disable extension loading again\n"
"con.enable_load_extension(False)\n"
"\n"
"# example from SQLite wiki\n"
"con.execute(\"CREATE VIRTUAL TABLE recipe USING fts3(name, ingredients)\")\n"
"con.executescript(\"\"\"\n"
"    INSERT INTO recipe (name, ingredients) VALUES('broccoli stew', 'broccoli peppers cheese tomatoes');\n"
"    INSERT INTO recipe (name, ingredients) VALUES('pumpkin stew', 'pumpkin onions garlic celery');\n"
"    INSERT INTO recipe (name, ingredients) VALUES('broccoli pie', 'broccoli cheese onions flour');\n"
"    INSERT INTO recipe (name, ingredients) VALUES('pumpkin pie', 'pumpkin sugar flour butter');\n"
"    \"\"\")\n"
"for row in con.execute(\"SELECT rowid, name, ingredients FROM recipe WHERE name MATCH 'pie'\"):\n"
"    print(row)"

msgid "Load an SQLite extension from a shared library. Enable extension loading with :meth:`enable_load_extension` before calling this method."
msgstr "یک افزونه‌ی SQLite را از یک کتابخانه مشترک بارگذاری کنید. پیش از فراخوانی این متد، بارگذاری افزونه را با :meth:`enable_load_extension` فعال کنید."

msgid "The path to the SQLite extension."
msgstr "مسیر افزونه‌ی SQLite."

msgid "Entry point name. If ``None`` (the default), SQLite will come up with an entry point name of its own; see the SQLite docs `Loading an Extension`_ for details."
msgstr "نام نقطه ورود. اگر ``None`` (پیش‌فرض) باشد، SQLite نام نقطه ورود خاص خود را انتخاب می‌کند؛ برای جزئیات، مستندات SQLite با عنوان `Loading an Extension`_ را ببینید."

msgid "Raises an :ref:`auditing event <auditing>` ``sqlite3.load_extension`` with arguments ``connection``, ``path``."
msgstr "یک :ref:`رویداد حسابرسی <auditing>` ``sqlite3.load_extension`` را با آرگومان‌های ``connection`` و ``path`` پرتاب می‌کند."

msgid "Added the ``sqlite3.load_extension`` auditing event."
msgstr "رویداد حسابرسی ``sqlite3.load_extension`` افزوده شد."

msgid "Added the *entrypoint* parameter."
msgstr "پارامتر *entrypoint* اضافه شد."

msgid "Return an :term:`iterator` to dump the database as SQL source code. Useful when saving an in-memory database for later restoration. Similar to the ``.dump`` command in the :program:`sqlite3` shell."
msgstr "یک :term:`iterator` برای برون‌ریزی پایگاه داده به‌صورت کد منبع SQL برمی‌گرداند. هنگام ذخیره‌ی یک پایگاه داده‌ی درون‌حافظه‌ای برای بازیابی بعدی مفید است. مشابه دستور ``.dump`` در پوسته‌ی :program:`sqlite3` است."

msgid "An optional ``LIKE`` pattern for database objects to dump, e.g. ``prefix_%``. If ``None`` (the default), all database objects will be included."
msgstr "یک الگوی ``LIKE`` اختیاری برای اشیای پایگاه داده‌ای که باید برون‌ریزی شوند، به‌عنوان مثال ``prefix_%``. اگر ``None`` (پیش‌فرض) باشد، تمام اشیای پایگاه داده گنجانده می‌شوند."

msgid ""
"# Convert file example.db to SQL dump file dump.sql\n"
"con = sqlite3.connect('example.db')\n"
"with open('dump.sql', 'w') as f:\n"
"    for line in con.iterdump():\n"
"        f.write('%s\\n' % line)\n"
"con.close()"
msgstr ""
"# Convert file example.db to SQL dump file dump.sql\n"
"con = sqlite3.connect('example.db')\n"
"with open('dump.sql', 'w') as f:\n"
"    for line in con.iterdump():\n"
"        f.write('%s\\n' % line)\n"
"con.close()"

msgid ":ref:`sqlite3-howto-encoding`"
msgstr ":ref:`sqlite3-howto-encoding`"

msgid "Added the *filter* parameter."
msgstr "پارامتر *filter* اضافه شد."

msgid "Create a backup of an SQLite database."
msgstr "یک نسخه پشتیبان از پایگاه‌داده SQLite ایجاد کنید."

msgid "Works even if the database is being accessed by other clients or concurrently by the same connection."
msgstr "حتی اگر پایگاه داده توسط کلاینت‌های دیگر یا به‌صورت همزمان توسط همان اتصال در حال دسترسی باشد، باز هم کار می‌کند."

msgid "The database connection to save the backup to."
msgstr "اتصال پایگاه داده‌ای که نسخه پشتیبان در آن ذخیره می‌شود."

msgid "The number of pages to copy at a time. If equal to or less than ``0``, the entire database is copied in a single step. Defaults to ``-1``."
msgstr "تعداد صفحه‌هایی که در هر نوبت کپی می‌شوند. اگر برابر یا کمتر از ``0`` باشد، کل پایگاه داده در یک مرحله کپی می‌شود. مقدار پیش‌فرض آن ``-1`` است."

msgid "If set to a :term:`callable`, it is invoked with three integer arguments for every backup iteration: the *status* of the last iteration, the *remaining* number of pages still to be copied, and the *total* number of pages. Defaults to ``None``."
msgstr "اگر به یک :term:`callable` تنظیم شود، در هر تکرار پشتیبان‌گیری با سه آرگومان عدد صحیحی فراخوانی می‌شود: *وضعیت* آخرین تکرار، تعداد صفحات *باقی‌مانده* که هنوز باید کپی شوند و تعداد *کل* صفحات. مقدار پیش‌فرض آن ``None`` است."

msgid "The name of the database to back up. Either ``\"main\"`` (the default) for the main database, ``\"temp\"`` for the temporary database, or the name of a custom database as attached using the ``ATTACH DATABASE`` SQL statement."
msgstr "نام پایگاه داده‌ای که از آن پشتیبان‌گیری می‌شود. یا ``\"main\"`` (پیش‌فرض) برای پایگاه داده اصلی، ``\"temp\"`` برای پایگاه داده موقت، یا نام یک پایگاه داده سفارشی که با دستور SQL ``ATTACH DATABASE`` متصل شده است."

msgid "The number of seconds to sleep between successive attempts to back up remaining pages."
msgstr "تعداد ثانیه‌های توقف بین تلاش‌های متوالی برای پشتیبان‌گیری صفحه‌های باقی‌مانده."

msgid "Example 1, copy an existing database into another:"
msgstr "مثال ۱، کپی کردن یک پایگاه داده‌ی موجود به پایگاه داده‌ای دیگر:"

msgid ""
"def progress(status, remaining, total):\n"
"    print(f'Copied {total-remaining} of {total} pages...')\n"
"\n"
"src = sqlite3.connect('example.db')\n"
"dst = sqlite3.connect('backup.db')\n"
"with dst:\n"
"    src.backup(dst, pages=1, progress=progress)\n"
"dst.close()\n"
"src.close()"
msgstr ""
"def progress(status, remaining, total):\n"
"    print(f'Copied {total-remaining} of {total} pages...')\n"
"\n"
"src = sqlite3.connect('example.db')\n"
"dst = sqlite3.connect('backup.db')\n"
"with dst:\n"
"    src.backup(dst, pages=1, progress=progress)\n"
"dst.close()\n"
"src.close()"

msgid "Example 2, copy an existing database into a transient copy:"
msgstr "مثال ۲، کپی یک پایگاه داده‌ی موجود به یک کپی گذرا:"

msgid ""
"src = sqlite3.connect('example.db')\n"
"dst = sqlite3.connect(':memory:')\n"
"src.backup(dst)\n"
"dst.close()\n"
"src.close()"
msgstr ""
"src = sqlite3.connect('example.db')\n"
"dst = sqlite3.connect(':memory:')\n"
"src.backup(dst)\n"
"dst.close()\n"
"src.close()"

msgid "Get a connection runtime limit."
msgstr "محدودیت ران‌تایم یک اتصال را دریافت کنید."

msgid "The `SQLite limit category`_ to be queried."
msgstr "`SQLite limit category`_ که باید پرس‌وجو شود."

msgid "If *category* is not recognised by the underlying SQLite library."
msgstr "اگر *category* توسط کتابخانه SQLite زیربنایی شناسایی نشود."

msgid "Example, query the maximum length of an SQL statement for :class:`Connection` ``con`` (the default is 1000000000):"
msgstr "مثال، حداکثر طول یک دستور SQL را برای :class:`Connection` ``con`` پرس‌وجو کنید (مقدار پیش‌فرض ۱۰۰۰۰۰۰۰۰۰ است):"

msgid ""
">>> con.getlimit(sqlite3.SQLITE_LIMIT_SQL_LENGTH)\n"
"1000000000"
msgstr ""
">>> con.getlimit(sqlite3.SQLITE_LIMIT_SQL_LENGTH)\n"
"1000000000"

msgid "Set a connection runtime limit. Attempts to increase a limit above its hard upper bound are silently truncated to the hard upper bound. Regardless of whether or not the limit was changed, the prior value of the limit is returned."
msgstr "یک محدودیت ران‌تایم اتصال را تنظیم می‌کند. اگر تلاش شود محدودیتی به بالاتر از کران بالایی سخت خود افزایش یابد، بدون هیچ پیامی به کران بالایی سخت تقلیل می‌یابد. صرف‌نظر از اینکه محدودیت تغییر کرده باشد یا خیر، مقدار پیشین محدودیت برگردانده می‌شود."

msgid "The `SQLite limit category`_ to be set."
msgstr "`SQLite limit category`_ که باید تنظیم شود."

msgid "The value of the new limit. If negative, the current limit is unchanged."
msgstr "مقدار محدودیت جدید. اگر منفی باشد، محدودیت فعلی بدون تغییر می‌ماند."

msgid "Example, limit the number of attached databases to 1 for :class:`Connection` ``con`` (the default limit is 10):"
msgstr "مثال، تعداد پایگاه‌های داده‌ی پیوست‌شده را برای :class:`Connection` ``con`` به ۱ محدود کنید (محدودیت پیش‌فرض ۱۰ است):"

msgid ""
">>> con.setlimit(sqlite3.SQLITE_LIMIT_ATTACHED, 1)\n"
"10\n"
">>> con.getlimit(sqlite3.SQLITE_LIMIT_ATTACHED)\n"
"1"
msgstr ""
">>> con.setlimit(sqlite3.SQLITE_LIMIT_ATTACHED, 1)\n"
"10\n"
">>> con.getlimit(sqlite3.SQLITE_LIMIT_ATTACHED)\n"
"1"

msgid "Query a boolean connection configuration option."
msgstr "یک گزینه‌ی پیکربندی اتصال بولی را پرس‌وجو کنید."

msgid "A :ref:`SQLITE_DBCONFIG code <sqlite3-dbconfig-constants>`."
msgstr "یک :ref:`کد SQLITE_DBCONFIG <sqlite3-dbconfig-constants>`."

msgid "Set a boolean connection configuration option."
msgstr "یک گزینه‌ی پیکربندی اتصال از نوع بولی را تنظیم کنید."

msgid "``True`` if the configuration option should be enabled (default); ``False`` if it should be disabled."
msgstr "``True`` اگر گزینه‌ی پیکربندی باید فعال باشد (پیش‌فرض)؛ ``False`` اگر باید غیرفعال باشد."

msgid "Serialize a database into a :class:`bytes` object.  For an ordinary on-disk database file, the serialization is just a copy of the disk file.  For an in-memory database or a \"temp\" database, the serialization is the same sequence of bytes which would be written to disk if that database were backed up to disk."
msgstr "یک پایگاه داده را به یک شیء :class:`bytes` سریال‌سازی می‌کند. برای یک پرونده پایگاه داده‌ی معمولی روی دیسک، سریال‌سازی صرفاً رونوشتی از پرونده دیسک است. برای یک پایگاه داده‌ی درون‌حافظه‌ای یا یک پایگاه داده‌ی \"temp\"، سریال‌سازی همان دنباله‌ای از بایت‌ها است که اگر آن پایگاه داده روی دیسک پشتیبان‌گیری می‌شد، روی دیسک نوشته می‌شد."

msgid "The database name to be serialized. Defaults to ``\"main\"``."
msgstr "نام پایگاه داده‌ای که باید سریال‌سازی شود. پیش‌فرض ``\"main\"`` است."

msgid "This method is only available if the underlying SQLite library has the serialize API."
msgstr "این متد فقط در صورتی در دسترس است که کتابخانه SQLite زیرین، دارای API سریال‌سازی (serialize) باشد."

msgid "Deserialize a :meth:`serialized <serialize>` database into a :class:`Connection`. This method causes the database connection to disconnect from database *name*, and reopen *name* as an in-memory database based on the serialization contained in *data*."
msgstr "یک پایگاه داده‌ی :meth:`سریال‌سازی‌شده <serialize>` را به یک :class:`Connection` از سریال‌سازی خارج کنید. این متد موجب می‌شود اتصال پایگاه داده از پایگاه داده‌ی *name* قطع شود و *name* به‌عنوان یک پایگاه داده‌ی درون‌حافظه‌ای بر اساس سریال‌سازی موجود در *data* بازگشایی شود."

msgid "A serialized database."
msgstr "یک پایگاه داده سریال‌سازی‌شده."

msgid "The database name to deserialize into. Defaults to ``\"main\"``."
msgstr "نام پایگاه داده مقصد برای سریال‌زدایی کردن (deserialize). پیش‌فرض آن ``\"main\"`` است."

msgid "If the database connection is currently involved in a read transaction or a backup operation."
msgstr "اگر اتصال پایگاه داده در حال حاضر درگیر یک تراکنش خواندن یا یک عملیات پشتیبان‌گیری باشد."

msgid "If *data* does not contain a valid SQLite database."
msgstr "اگر *data* شامل یک پایگاه داده SQLite معتبر نباشد."

msgid "If :func:`len(data) <len>` is larger than ``2**63 - 1``."
msgstr "اگر :func:`len(data) <len>` بزرگ‌تر از ``2**63 - 1`` باشد."

msgid "This method is only available if the underlying SQLite library has the deserialize API."
msgstr "این متد تنها در صورتی در دسترس است که کتابخانه SQLite زیرین دارای API سریال‌زدایی کردن (deserialize) باشد."

msgid "This attribute controls :pep:`249`-compliant transaction behaviour. :attr:`!autocommit` has three allowed values:"
msgstr "این ویژگی رفتار تراکنش مطابق با :pep:`249` را کنترل می‌کند. :attr:`!autocommit` سه مقدار مجاز دارد:"

msgid "``False``: Select :pep:`249`-compliant transaction behaviour, implying that :mod:`!sqlite3` ensures a transaction is always open. Use :meth:`commit` and :meth:`rollback` to close transactions."
msgstr "``False``: رفتار تراکنشی مطابق :pep:`249` را انتخاب می‌کند، به این معنا که :mod:`!sqlite3` تضمین می‌کند یک تراکنش همیشه باز است. برای بستن تراکنش‌ها از :meth:`commit` و :meth:`rollback` استفاده کنید."

msgid "This is the recommended value of :attr:`!autocommit`."
msgstr "این مقدار توصیه‌شده برای :attr:`!autocommit` است."

msgid "``True``: Use SQLite's `autocommit mode`_. :meth:`commit` and :meth:`rollback` have no effect in this mode."
msgstr "``True``: از `autocommit mode`_ SQLite استفاده کنید. در این حالت، :meth:`commit` و :meth:`rollback` هیچ تأثیری ندارند."

msgid ":data:`LEGACY_TRANSACTION_CONTROL`: Pre-Python 3.12 (non-:pep:`249`-compliant) transaction control. See :attr:`isolation_level` for more details."
msgstr ":data:`LEGACY_TRANSACTION_CONTROL`: کنترل تراکنش پیش از پایتون 3.12 (ناسازگار با :pep:`249`). برای جزئیات بیشتر :attr:`isolation_level` را ببینید."

msgid "This is currently the default value of :attr:`!autocommit`."
msgstr "این در حال حاضر مقدار پیش‌فرض :attr:`!autocommit` است."

msgid "Changing :attr:`!autocommit` to ``False`` will open a new transaction, and changing it to ``True`` will commit any pending transaction."
msgstr "تغییر :attr:`!autocommit` به ``False`` یک تراکنش جدید را باز می‌کند، و تغییر آن به ``True`` هر تراکنش در انتظار را ثبت (commit) می‌کند."

msgid "See :ref:`sqlite3-transaction-control-autocommit` for more details."
msgstr "برای جزئیات بیشتر به :ref:`sqlite3-transaction-control-autocommit` مراجعه کنید."

msgid "The :attr:`isolation_level` attribute has no effect unless :attr:`autocommit` is :data:`LEGACY_TRANSACTION_CONTROL`."
msgstr "ویژگی :attr:`isolation_level` تأثیری ندارد، مگر اینکه :attr:`autocommit` برابر :data:`LEGACY_TRANSACTION_CONTROL` باشد."

msgid "This read-only attribute corresponds to the low-level SQLite `autocommit mode`_."
msgstr "این ویژگی فقط‌خواندنی، متناظر با حالت `autocommit mode`_ سطح پایین در SQLite است."

msgid "``True`` if a transaction is active (there are uncommitted changes), ``False`` otherwise."
msgstr "اگر یک تراکنش فعال باشد (تغییرات ثبت‌نشده‌ای وجود داشته باشد)، ``True`` و در غیر این صورت ``False`` است."

msgid "Controls the :ref:`legacy transaction handling mode <sqlite3-transaction-control-isolation-level>` of :mod:`!sqlite3`. If set to ``None``, transactions are never implicitly opened. If set to one of ``\"DEFERRED\"``, ``\"IMMEDIATE\"``, or ``\"EXCLUSIVE\"``, corresponding to the underlying `SQLite transaction behaviour`_, :ref:`implicit transaction management <sqlite3-transaction-control-isolation-level>` is performed."
msgstr ":ref:`حالت مدیریت تراکنش قدیمی <sqlite3-transaction-control-isolation-level>` در :mod:`!sqlite3` را کنترل می‌کند. اگر روی ``None`` تنظیم شود، تراکنش‌ها هرگز به‌صورت ضمنی باز نمی‌شوند. اگر روی یکی از ``\"DEFERRED\"``، ``\"IMMEDIATE\"`` یا ``\"EXCLUSIVE\"`` تنظیم شود، مطابق با `SQLite transaction behaviour`_ زیربنایی، :ref:`مدیریت ضمنی تراکنش <sqlite3-transaction-control-isolation-level>` انجام می‌شود."

msgid "If not overridden by the *isolation_level* parameter of :func:`connect`, the default is ``\"\"``, which is an alias for ``\"DEFERRED\"``."
msgstr "اگر پارامتر *isolation_level* در :func:`connect` آن را بازنویسی نکند، مقدار پیش‌فرض ``\"\"`` است که نام مستعاری برای ``\"DEFERRED\"`` محسوب می‌شود."

msgid "Using :attr:`autocommit` to control transaction handling is recommended over using :attr:`!isolation_level`. :attr:`!isolation_level` has no effect unless :attr:`autocommit` is set to :data:`LEGACY_TRANSACTION_CONTROL` (the default)."
msgstr "استفاده از :attr:`autocommit` برای کنترل مدیریت تراکنش، به‌جای استفاده از :attr:`!isolation_level` توصیه می‌شود. :attr:`!isolation_level` هیچ تأثیری ندارد، مگر اینکه :attr:`autocommit` روی :data:`LEGACY_TRANSACTION_CONTROL` (پیش‌فرض) تنظیم شده باشد."

msgid "The initial :attr:`~Cursor.row_factory` for :class:`Cursor` objects created from this connection. Assigning to this attribute does not affect the :attr:`!row_factory` of existing cursors belonging to this connection, only new ones. Is ``None`` by default, meaning each row is returned as a :class:`tuple`."
msgstr ":attr:`~Cursor.row_factory` اولیه برای اشیای :class:`Cursor` ایجادشده از این اتصال. انتساب به این ویژگی بر :attr:`!row_factory` نشانگرهای موجود متعلق به این اتصال تأثیری نمی‌گذارد و فقط نشانگرهای جدید را تحت تأثیر قرار می‌دهد. به‌طور پیش‌فرض ``None`` است، به این معنا که هر ردیف به‌صورت یک :class:`tuple` بازگردانده می‌شود."

msgid "See :ref:`sqlite3-howto-row-factory` for more details."
msgstr "برای جزئیات بیشتر :ref:`sqlite3-howto-row-factory` را ببینید."

msgid "Deleting the ``row_factory`` attribute is no longer allowed."
msgstr "حذف ویژگی ``row_factory`` دیگر مجاز نیست."

msgid "A :term:`callable` that accepts a :class:`bytes` parameter and returns a text representation of it. The callable is invoked for SQLite values with the ``TEXT`` data type. By default, this attribute is set to :class:`str`."
msgstr "یک :term:`callable` که یک پارامتر از نوع :class:`bytes` را می‌پذیرد و یک نمایش متنی از آن را برمی‌گرداند. این callable برای مقادیر SQLite با نوع داده ``TEXT`` فراخوانی می‌شود. به‌طور پیش‌فرض، این ویژگی روی :class:`str` تنظیم شده است."

msgid "See :ref:`sqlite3-howto-encoding` for more details."
msgstr "برای جزئیات بیشتر :ref:`sqlite3-howto-encoding` را ببینید."

msgid "Deleting the ``text_factory`` attribute is no longer allowed."
msgstr "حذف ویژگی ``text_factory`` دیگر مجاز نیست."

msgid "Return the total number of database rows that have been modified, inserted, or deleted since the database connection was opened."
msgstr "تعداد کل ردیف‌های پایگاه داده را که از زمان باز شدن اتصال پایگاه داده تغییریافته، درج‌شده یا حذف‌شده‌اند، برمی‌گرداند."

msgid "Cursor objects"
msgstr "اشیای نشانگر"

msgid "A ``Cursor`` object represents a `database cursor`_ which is used to execute SQL statements, and manage the context of a fetch operation. Cursors are created using :meth:`Connection.cursor`, or by using any of the :ref:`connection shortcut methods <sqlite3-connection-shortcuts>`."
msgstr "یک شیء ``Cursor`` نشان‌دهنده‌ی یک `database cursor`_ است که برای اجرای دستورات SQL و مدیریت زمینه‌ی یک عملیات واکشی استفاده می‌شود. نشانگرها با استفاده از :meth:`Connection.cursor`، یا با استفاده از هر یک از :ref:`متدهای میان‌بر اتصال <sqlite3-connection-shortcuts>` ایجاد می‌شوند."

msgid "Cursor objects are :term:`iterators <iterator>`, meaning that if you :meth:`~Cursor.execute` a ``SELECT`` query, you can simply iterate over the cursor to fetch the resulting rows:"
msgstr "اشیاء Cursor از نوع :term:`پیمایش‌گر <iterator>` هستند، به این معنا که اگر یک پرس‌وجوی ``SELECT`` را :meth:`~Cursor.execute` کنید، می‌توانید برای واکشی ردیف‌های حاصل، به‌سادگی روی نشانگر پیمایش کنید:"

msgid ""
"for row in cur.execute(\"SELECT t FROM data\"):\n"
"    print(row)"
msgstr ""
"for row in cur.execute(\"SELECT t FROM data\"):\n"
"    print(row)"

msgid "A :class:`Cursor` instance has the following attributes and methods."
msgstr "یک نمونه :class:`Cursor` دارای ویژگی‌ها و متدهای زیر است."

msgid "Execute a single SQL statement, optionally binding Python values using :ref:`placeholders <sqlite3-placeholders>`."
msgstr "یک دستور SQL واحد را اجرا کنید و به‌صورت اختیاری مقادیر پایتون را با استفاده از :ref:`جای‌نگهدارها <sqlite3-placeholders>` مقید کنید."

msgid "A single SQL statement."
msgstr "یک دستور SQL واحد."

msgid "Python values to bind to placeholders in *sql*. A :class:`!dict` if named placeholders are used. A :term:`!sequence` if unnamed placeholders are used. See :ref:`sqlite3-placeholders`."
msgstr "مقادیر پایتون برای مقیدسازی به جای‌نگهدارها در *sql*. در صورت استفاده از جای‌نگهدارهای نام‌دار، یک :class:`!dict`. در صورت استفاده از جای‌نگهدارهای بی‌نام، یک :term:`!sequence`. :ref:`sqlite3-placeholders` را ببینید."

msgid "When *sql* contains more than one SQL statement. When :ref:`named placeholders <sqlite3-placeholders>` are used and *parameters* is a sequence instead of a :class:`dict`."
msgstr "هنگامی که *sql* شامل بیش از یک دستور SQL باشد. هنگامی که از :ref:`جای‌نگهدارهای نام‌گذاری‌شده <sqlite3-placeholders>` استفاده می‌شود و *parameters* به‌جای یک :class:`dict` یک دنباله باشد."

msgid "If :attr:`~Connection.autocommit` is :data:`LEGACY_TRANSACTION_CONTROL`, :attr:`~Connection.isolation_level` is not ``None``, *sql* is an ``INSERT``, ``UPDATE``, ``DELETE``, or ``REPLACE`` statement, and there is no open transaction, a transaction is implicitly opened before executing *sql*."
msgstr "اگر :attr:`~Connection.autocommit` برابر :data:`LEGACY_TRANSACTION_CONTROL` باشد، :attr:`~Connection.isolation_level` برابر ``None`` نباشد، *sql* یک دستور ``INSERT``، ``UPDATE``، ``DELETE`` یا ``REPLACE`` باشد و هیچ تراکنش بازی وجود نداشته باشد، پیش از اجرای *sql*، یک تراکنش به‌طور ضمنی باز می‌شود."

msgid ":exc:`ProgrammingError` is emitted if :ref:`named placeholders <sqlite3-placeholders>` are used and *parameters* is a sequence instead of a :class:`dict`."
msgstr ":exc:`ProgrammingError` پرتاب می‌شود، اگر از :ref:`جای‌نگهدارهای نام‌دار <sqlite3-placeholders>` استفاده شود و *parameters* به‌جای یک :class:`dict` یک دنباله باشد."

msgid "Use :meth:`executescript` to execute multiple SQL statements."
msgstr "برای اجرای چندین دستور SQL از :meth:`executescript` استفاده کنید."

msgid "For every item in *parameters*, repeatedly execute the :ref:`parameterized <sqlite3-placeholders>` :abbr:`DML (Data Manipulation Language)` SQL statement *sql*."
msgstr "به ازای هر آیتم در *parameters*، دستور SQL :abbr:`DML (زبان دست‌کاری داده‌ها) <DML (Data Manipulation Language)>` :ref:`پارامتریزه <sqlite3-placeholders>` *sql* را به‌طور مکرر اجرا کنید."

msgid "Uses the same implicit transaction handling as :meth:`~Cursor.execute`."
msgstr "از همان مدیریت تراکنش ضمنیِ :meth:`~Cursor.execute` استفاده می‌کند."

msgid "A single SQL DML statement."
msgstr "یک دستور SQL DML."

msgid "An :term:`!iterable` of parameters to bind with the placeholders in *sql*. See :ref:`sqlite3-placeholders`."
msgstr "یک :term:`!iterable` از پارامترها برای مقیدسازی با جای‌نگهدارها در *sql*. :ref:`sqlite3-placeholders` را ببینید."

msgid "When *sql* contains more than one SQL statement or is not a DML statement, When :ref:`named placeholders <sqlite3-placeholders>` are used and the items in *parameters* are sequences instead of :class:`dict`\\s."
msgstr "هنگامی که *sql* شامل بیش از یک دستور SQL باشد یا یک دستور DML نباشد، هنگامی که از :ref:`جای‌نگهدارهای نام‌گذاری‌شده <sqlite3-placeholders>` استفاده شود و آیتم‌های *parameters* به جای :class:`dict`\\s دنباله باشند."

msgid ""
"rows = [\n"
"    (\"row1\",),\n"
"    (\"row2\",),\n"
"]\n"
"# cur is an sqlite3.Cursor object\n"
"cur.executemany(\"INSERT INTO data VALUES(?)\", rows)"
msgstr ""
"rows = [\n"
"    (\"row1\",),\n"
"    (\"row2\",),\n"
"]\n"
"# cur is an sqlite3.Cursor object\n"
"cur.executemany(\"INSERT INTO data VALUES(?)\", rows)"

msgid "Any resulting rows are discarded, including DML statements with `RETURNING clauses`_."
msgstr "هر ردیف حاصل دور ریخته می‌شود، از جمله در دستورات DML با `RETURNING clauses`_."

msgid ":exc:`ProgrammingError` is emitted if :ref:`named placeholders <sqlite3-placeholders>` are used and the items in *parameters* are sequences instead of :class:`dict`\\s."
msgstr "اگر از :ref:`جای‌نگهدارهای نام‌دار <sqlite3-placeholders>` استفاده شود و آیتم‌های درون *parameters* به‌جای :class:`dict`\\s دنباله باشند، :exc:`ProgrammingError` پرتاب می‌شود."

msgid "Execute the SQL statements in *sql_script*. If the :attr:`~Connection.autocommit` is :data:`LEGACY_TRANSACTION_CONTROL` and there is a pending transaction, an implicit ``COMMIT`` statement is executed first. No other implicit transaction control is performed; any transaction control must be added to *sql_script*."
msgstr "دستورات SQL موجود در *sql_script* را اجرا کنید. اگر :attr:`~Connection.autocommit` برابر :data:`LEGACY_TRANSACTION_CONTROL` باشد و یک تراکنش در انتظار وجود داشته باشد، ابتدا یک دستور ``COMMIT`` ضمنی اجرا می‌شود. هیچ‌گونه کنترل تراکنش ضمنی دیگری انجام نمی‌شود؛ هرگونه کنترل تراکنش باید به *sql_script* اضافه شود."

msgid "*sql_script* must be a :class:`string <str>`."
msgstr "*sql_script* باید یک :class:`رشته <str>` باشد."

msgid ""
"# cur is an sqlite3.Cursor object\n"
"cur.executescript(\"\"\"\n"
"    BEGIN;\n"
"    CREATE TABLE person(firstname, lastname, age);\n"
"    CREATE TABLE book(title, author, published);\n"
"    CREATE TABLE publisher(name, address);\n"
"    COMMIT;\n"
"\"\"\")"
msgstr ""
"# cur is an sqlite3.Cursor object\n"
"cur.executescript(\"\"\"\n"
"    BEGIN;\n"
"    CREATE TABLE person(firstname, lastname, age);\n"
"    CREATE TABLE book(title, author, published);\n"
"    CREATE TABLE publisher(name, address);\n"
"    COMMIT;\n"
"\"\"\")"

msgid "If :attr:`~Cursor.row_factory` is ``None``, return the next row query result set as a :class:`tuple`. Else, pass it to the row factory and return its result. Return ``None`` if no more data is available."
msgstr "اگر :attr:`~Cursor.row_factory` ``None`` باشد، ردیف بعدی از مجموعه‌ی نتایج پرس‌وجو را به‌صورت یک :class:`tuple` برمی‌گرداند. در غیر این صورت، آن را به کارخانه‌ی ردیف (row factory) می‌دهد و نتیجه‌ی آن را برمی‌گرداند. اگر داده‌ی بیشتری در دسترس نباشد، ``None`` را برمی‌گرداند."

msgid "Return the next set of rows of a query result as a :class:`list`. Return an empty list if no more rows are available."
msgstr "برگرداندن دسته‌ی بعدی از ردیف‌های نتیجه‌ی یک پرس‌وجو به‌عنوان یک :class:`list`. اگر دیگر ردیفی در دسترس نباشد، یک فهرست خالی برمی‌گرداند."

msgid "The number of rows to fetch per call is specified by the *size* parameter. If *size* is not given, :attr:`arraysize` determines the number of rows to be fetched. If fewer than *size* rows are available, as many rows as are available are returned."
msgstr "تعداد ردیفهایی که در هر فراخوانی واکشی می‌شوند، با پارامتر *size* مشخص می‌شود. اگر *size* داده نشود، :attr:`arraysize` تعداد ردیفهای واکشی‌شده را تعیین می‌کند. اگر کمتر از *size* ردیف در دسترس باشد، هر تعداد ردیفی که در دسترس باشد بازگردانده می‌شود."

msgid "Note there are performance considerations involved with the *size* parameter. For optimal performance, it is usually best to use the arraysize attribute. If the *size* parameter is used, then it is best for it to retain the same value from one :meth:`fetchmany` call to the next."
msgstr "توجه داشته باشید که ملاحظات عملکردی مرتبط با پارامتر *size* وجود دارد. برای عملکرد بهینه، معمولاً بهتر است از ویژگی arraysize استفاده کنید. اگر از پارامتر *size* استفاده می‌شود، بهتر است مقدار آن از یک فراخوانی :meth:`fetchmany` تا فراخوانی بعدی ثابت بماند."

msgid "Negative *size* values are rejected by raising :exc:`ValueError`."
msgstr "مقادیر منفی *size* با پرتاب :exc:`ValueError` رد می‌شوند."

msgid "Return all (remaining) rows of a query result as a :class:`list`. Return an empty list if no rows are available. Note that the :attr:`arraysize` attribute can affect the performance of this operation."
msgstr "تمام ردیف‌های (باقی‌مانده) نتیجه‌ی پرس‌وجو را به‌صورت یک :class:`list` برمی‌گرداند. اگر هیچ ردیفی موجود نباشد، یک فهرست خالی برمی‌گرداند. توجه داشته باشید که ویژگی :attr:`arraysize` می‌تواند بر عملکرد این عملیات تأثیر بگذارد."

msgid "Close the cursor now (rather than whenever ``__del__`` is called)."
msgstr "اکنون نشانگر را ببندید (نه هر زمان که ``__del__`` فراخوانی می‌شود)."

msgid "The cursor will be unusable from this point forward; a :exc:`ProgrammingError` exception will be raised if any operation is attempted with the cursor."
msgstr "از این نقطه به بعد، نشانگر غیرقابل استفاده خواهد بود؛ در صورت تلاش برای انجام هر عملیاتی با نشانگر، استثنای :exc:`ProgrammingError` پرتاب خواهد شد."

msgid "Required by the DB-API. Does nothing in :mod:`!sqlite3`."
msgstr "مورد نیاز DB-API است. در :mod:`!sqlite3` هیچ کاری انجام نمی‌دهد."

msgid "Read/write attribute that controls the number of rows returned by :meth:`fetchmany`. The default value is 1 which means a single row would be fetched per call."
msgstr "ویژگی خواندنی/نوشتنی که تعداد ردیف‌های بازگردانده‌شده توسط :meth:`fetchmany` را کنترل می‌کند. مقدار پیش‌فرض ۱ است، یعنی در هر فراخوانی یک ردیف واکشی می‌شود."

msgid "Negative values are rejected by raising :exc:`ValueError`."
msgstr "مقادیر منفی با پرتاب :exc:`ValueError` رد می‌شوند."

msgid "Read-only attribute that provides the SQLite database :class:`Connection` belonging to the cursor.  A :class:`Cursor` object created by calling :meth:`con.cursor() <Connection.cursor>` will have a :attr:`connection` attribute that refers to *con*:"
msgstr "ویژگی فقط‌خواندنی که :class:`Connection` پایگاه داده‌ی SQLite متعلق به نشانگر را فراهم می‌کند. یک شیء :class:`Cursor` که با فراخوانی :meth:`con.cursor() <Connection.cursor>` ایجاد شده باشد، ویژگی :attr:`connection` خواهد داشت که به *con* ارجاع می‌دهد:"

msgid ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> cur = con.cursor()\n"
">>> cur.connection == con\n"
"True\n"
">>> con.close()"
msgstr ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> cur = con.cursor()\n"
">>> cur.connection == con\n"
"True\n"
">>> con.close()"

msgid "Read-only attribute that provides the column names of the last query. To remain compatible with the Python DB API, it returns a 7-tuple for each column where the last six items of each tuple are ``None``."
msgstr "ویژگی فقط‌خواندنی که نام ستون‌های آخرین پرس‌وجو را ارائه می‌دهد. برای حفظ سازگاری با Python DB API، برای هر ستون یک تاپل ۷تایی بازمی‌گرداند که شش آیتم پایانی هر تاپل ``None`` هستند."

msgid "It is set for ``SELECT`` statements without any matching rows as well."
msgstr "این ویژگی برای دستورهای ``SELECT`` که هیچ ردیف منطبقی ندارند نیز تنظیم می‌شود."

msgid "Read-only attribute that provides the row id of the last inserted row. It is only updated after successful ``INSERT`` or ``REPLACE`` statements using the :meth:`execute` method.  For other statements, after :meth:`executemany` or :meth:`executescript`, or if the insertion failed, the value of ``lastrowid`` is left unchanged.  The initial value of ``lastrowid`` is ``None``."
msgstr "ویژگی فقط‌خواندنی که شناسه‌ی آخرین ردیف درج‌شده را فراهم می‌کند. این ویژگی فقط پس از دستورهای موفق ``INSERT`` یا ``REPLACE`` با استفاده از متد :meth:`execute` به‌روزرسانی می‌شود. برای دستورهای دیگر، پس از :meth:`executemany` یا :meth:`executescript`، یا اگر درج ناموفق باشد، مقدار ``lastrowid`` بدون تغییر باقی می‌ماند. مقدار اولیه‌ی ``lastrowid`` برابر ``None`` است."

msgid "Inserts into ``WITHOUT ROWID`` tables are not recorded."
msgstr "درج‌ها در جدول‌های ``WITHOUT ROWID`` ثبت نمی‌شوند."

msgid "Added support for the ``REPLACE`` statement."
msgstr "پشتیبانی از دستور ``REPLACE`` افزوده شد."

msgid "Read-only attribute that provides the number of modified rows for ``INSERT``, ``UPDATE``, ``DELETE``, and ``REPLACE`` statements; is ``-1`` for other statements, including :abbr:`CTE (Common Table Expression)` queries. It is only updated by the :meth:`execute` and :meth:`executemany` methods, after the statement has run to completion. This means that any resulting rows must be fetched in order for :attr:`!rowcount` to be updated."
msgstr "ویژگی فقط‌خواندنی که تعداد ردیفهای تغییرکرده توسط دستورهای ``INSERT``، ``UPDATE``، ``DELETE`` و ``REPLACE`` را ارائه می‌دهد؛ برای سایر دستورها، از جمله پرس‌وجوهای :abbr:`CTE (Common Table Expression)`، ``-1`` است. این ویژگی فقط توسط متدهای :meth:`execute` و :meth:`executemany`، پس از اجرای کامل دستور به‌روزرسانی می‌شود. این بدان معناست که برای به‌روزرسانی :attr:`!rowcount` باید همه ردیفهای حاصل واکشی شوند."

msgid "Control how a row fetched from this :class:`!Cursor` is represented. If ``None``, a row is represented as a :class:`tuple`. Can be set to the included :class:`sqlite3.Row`; or a :term:`callable` that accepts two arguments, a :class:`Cursor` object and the :class:`!tuple` of row values, and returns a custom object representing an SQLite row."
msgstr "چگونگی بازنمایی ردیفی را که از این :class:`!Cursor` واکشی می‌شود، کنترل می‌کند. اگر ``None`` باشد، یک ردیف به‌صورت یک :class:`tuple` بازنمایی می‌شود. می‌توان آن را روی :class:`sqlite3.Row` ارائه‌شده تنظیم کرد؛ یا روی یک :term:`callable` که دو آرگومان می‌پذیرد، یک شیء :class:`Cursor` و :class:`!tuple` مقدارهای ردیف، و یک شیء سفارشی را بازمی‌گرداند که یک ردیف SQLite را بازنمایی می‌کند."

msgid "Defaults to what :attr:`Connection.row_factory` was set to when the :class:`!Cursor` was created. Assigning to this attribute does not affect :attr:`Connection.row_factory` of the parent connection."
msgstr "به‌طور پیش‌فرض برابر مقداری است که :attr:`Connection.row_factory` هنگام ایجاد :class:`!Cursor` روی آن تنظیم شده است. انتساب به این ویژگی بر :attr:`Connection.row_factory` اتصال والد تأثیری نمی‌گذارد."

msgid "Row objects"
msgstr "اشیای Row"

msgid "A :class:`!Row` instance serves as a highly optimized :attr:`~Connection.row_factory` for :class:`Connection` objects. It supports iteration, equality testing, :func:`len`, and :term:`mapping` access by column name and index."
msgstr "نمونه‌ای از :class:`!Row` به‌عنوان یک :attr:`~Connection.row_factory` بسیار بهینه‌شده برای اشیای :class:`Connection` عمل می‌کند. این نمونه از تکرار، آزمون برابری، :func:`len` و دسترسی به‌صورت :term:`mapping` از طریق نام و اندیس ستون پشتیبانی می‌کند."

msgid "Two :class:`!Row` objects compare equal if they have identical column names and values."
msgstr "دو شیء :class:`!Row` زمانی برابر مقایسه می‌شوند که نام‌ها و مقادیر ستون‌های یکسانی داشته باشند."

msgid "Return a :class:`list` of column names as :class:`strings <str>`. Immediately after a query, it is the first member of each tuple in :attr:`Cursor.description`."
msgstr "یک :class:`list` از نام ستون‌ها به‌صورت :class:`strings <str>` برمی‌گرداند. بلافاصله پس از یک پرس‌وجو، اولین عضو هر تاپل در :attr:`Cursor.description` است."

msgid "Added support of slicing."
msgstr "پشتیبانی از اسلایس افزوده شد."

msgid "Blob objects"
msgstr "اشیای Blob"

msgid "A :class:`Blob` instance is a :term:`file-like object` that can read and write data in an SQLite :abbr:`BLOB (Binary Large OBject)`. Call :func:`len(blob) <len>` to get the size (number of bytes) of the blob. Use indices and :term:`slices <slice>` for direct access to the blob data."
msgstr "یک نمونه از :class:`Blob` یک :term:`شیء شبه‌پرونده <file-like object>` است که می‌تواند داده‌ها را در یک :abbr:`BLOB (Binary Large OBject)` مربوط به SQLite بخواند و بنویسد. برای دریافت اندازه‌ی blob (یعنی تعداد بایت‌های آن)، :func:`len(blob) <len>` را فراخوانی کنید. برای دسترسی مستقیم به داده‌های blob، از اندیس‌ها و :term:`اسلایس‌ها <slice>` استفاده کنید."

msgid "Use the :class:`Blob` as a :term:`context manager` to ensure that the blob handle is closed after use."
msgstr "از :class:`Blob` به‌عنوان یک :term:`context manager` استفاده کنید تا اطمینان حاصل شود که دسته‌ی blob پس از استفاده بسته می‌شود."

msgid ""
"con = sqlite3.connect(\":memory:\")\n"
"con.execute(\"CREATE TABLE test(blob_col blob)\")\n"
"con.execute(\"INSERT INTO test(blob_col) VALUES(zeroblob(13))\")\n"
"\n"
"# Write to our blob, using two write operations:\n"
"with con.blobopen(\"test\", \"blob_col\", 1) as blob:\n"
"    blob.write(b\"hello, \")\n"
"    blob.write(b\"world.\")\n"
"    # Modify the first and last bytes of our blob\n"
"    blob[0] = ord(\"H\")\n"
"    blob[-1] = ord(\"!\")\n"
"\n"
"# Read the contents of our blob\n"
"with con.blobopen(\"test\", \"blob_col\", 1) as blob:\n"
"    greeting = blob.read()\n"
"\n"
"print(greeting)  # outputs \"b'Hello, world!'\"\n"
"con.close()"
msgstr ""
"con = sqlite3.connect(\":memory:\")\n"
"con.execute(\"CREATE TABLE test(blob_col blob)\")\n"
"con.execute(\"INSERT INTO test(blob_col) VALUES(zeroblob(13))\")\n"
"\n"
"# Write to our blob, using two write operations:\n"
"with con.blobopen(\"test\", \"blob_col\", 1) as blob:\n"
"    blob.write(b\"hello, \")\n"
"    blob.write(b\"world.\")\n"
"    # Modify the first and last bytes of our blob\n"
"    blob[0] = ord(\"H\")\n"
"    blob[-1] = ord(\"!\")\n"
"\n"
"# Read the contents of our blob\n"
"with con.blobopen(\"test\", \"blob_col\", 1) as blob:\n"
"    greeting = blob.read()\n"
"\n"
"print(greeting)  # outputs \"b'Hello, world!'\"\n"
"con.close()"

msgid "Close the blob."
msgstr "بلاب را ببندید."

msgid "The blob will be unusable from this point onward.  An :class:`~sqlite3.Error` (or subclass) exception will be raised if any further operation is attempted with the blob."
msgstr "این blob از این نقطه به بعد غیرقابل استفاده خواهد بود. در صورت تلاش برای انجام هر عملیات دیگری با blob، یک استثنای :class:`~sqlite3.Error` (یا زیرکلاس آن) پرتاب خواهد شد."

msgid "Read *length* bytes of data from the blob at the current offset position. If the end of the blob is reached, the data up to :abbr:`EOF (End of File)` will be returned.  When *length* is not specified, or is negative, :meth:`~Blob.read` will read until the end of the blob."
msgstr "*length* بایت داده از بلاب در موقعیت فعلی آفست خوانده می‌شود. اگر به انتهای بلاب رسیده شود، داده تا :abbr:`EOF (End of File)` بازگردانده می‌شود. هنگامی که *length* مشخص نشده باشد یا منفی باشد، :meth:`~Blob.read` تا انتهای بلاب می‌خواند."

msgid "Write *data* to the blob at the current offset.  This function cannot change the blob length.  Writing beyond the end of the blob will raise :exc:`ValueError`."
msgstr "*data* را در آفست فعلی بلاب بنویسید. این تابع نمی‌تواند طول بلاب را تغییر دهد. نوشتن فراتر از انتهای بلاب باعث پرتاب :exc:`ValueError` می‌شود."

msgid "Return the current access position of the blob."
msgstr "موقعیت دسترسی جاری بلاب را برمی‌گرداند."

msgid "Set the current access position of the blob to *offset*.  The *origin* argument defaults to :const:`os.SEEK_SET` (absolute blob positioning). Other values for *origin* are :const:`os.SEEK_CUR` (seek relative to the current position) and :const:`os.SEEK_END` (seek relative to the blob’s end)."
msgstr "موقعیت دسترسی فعلی بلاب را روی *offset* تنظیم می‌کند. آرگومان *origin* به‌طور پیش‌فرض :const:`os.SEEK_SET` (موقعیت‌دهی مطلق بلاب) است. مقادیر دیگر برای *origin* عبارت‌اند از :const:`os.SEEK_CUR` (جابه‌جایی نسبت به موقعیت فعلی) و :const:`os.SEEK_END` (جابه‌جایی نسبت به انتهای بلاب)."

msgid "PrepareProtocol objects"
msgstr "اشیای PrepareProtocol"

msgid "The PrepareProtocol type's single purpose is to act as a :pep:`246` style adaption protocol for objects that can :ref:`adapt themselves <sqlite3-conform>` to :ref:`native SQLite types <sqlite3-types>`."
msgstr "تنها هدف نوع PrepareProtocol این است که به‌عنوان یک پروتکل تطبیق به سبک :pep:`246` برای اشیایی عمل کند که می‌توانند :ref:`خود را وفق دهند <sqlite3-conform>` به :ref:`انواع ذاتی SQLite <sqlite3-types>`."

msgid "Exceptions"
msgstr "استثناها"

msgid "The exception hierarchy is defined by the DB-API 2.0 (:pep:`249`)."
msgstr "سلسله‌مراتب استثنا توسط DB-API 2.0 تعریف شده است (:pep:`249`)."

msgid "This exception is not currently raised by the :mod:`!sqlite3` module, but may be raised by applications using :mod:`!sqlite3`, for example if a user-defined function truncates data while inserting. ``Warning`` is a subclass of :exc:`Exception`."
msgstr "این استثنا در حال حاضر توسط ماژول :mod:`!sqlite3` پرتاب نمی‌شود، اما ممکن است توسط برنامه‌هایی که از :mod:`!sqlite3` استفاده می‌کنند پرتاب شود، برای مثال اگر یک تابع تعریف‌شده توسط کاربر هنگام درج، داده‌ها را کوتاه کند. ``Warning`` زیرکلاسی از :exc:`Exception` است."

msgid "The base class of the other exceptions in this module. Use this to catch all errors with one single :keyword:`except` statement. ``Error`` is a subclass of :exc:`Exception`."
msgstr "کلاس پایه‌ی سایر استثناهای این ماژول. از این برای گرفتن همه‌ی خطاها با یک دستور :keyword:`except` واحد استفاده کنید. ``Error`` یک زیرکلاس از :exc:`Exception` است."

msgid "If the exception originated from within the SQLite library, the following two attributes are added to the exception:"
msgstr "اگر استثنا از درون کتابخانه SQLite سرچشمه گرفته باشد، دو ویژگی زیر به استثنا اضافه می‌شوند:"

msgid "The numeric error code from the `SQLite API <https://sqlite.org/rescode.html>`_"
msgstr "کد خطای عددی از `SQLite API <https://sqlite.org/rescode.html>`_"

msgid "The symbolic name of the numeric error code from the `SQLite API <https://sqlite.org/rescode.html>`_"
msgstr "نام نمادینِ کد خطای عددی از `SQLite API <https://sqlite.org/rescode.html>`_"

msgid "Exception raised for misuse of the low-level SQLite C API. In other words, if this exception is raised, it probably indicates a bug in the :mod:`!sqlite3` module. ``InterfaceError`` is a subclass of :exc:`Error`."
msgstr "استثنایی که برای استفاده‌ی نادرست از API سطح پایین C در SQLite پرتاب می‌شود. به عبارت دیگر، اگر این استثنا پرتاب شد، احتمالاً نشان‌دهنده‌ی یک خطا در ماژول :mod:`!sqlite3` است. ``InterfaceError`` زیرکلاسی از :exc:`Error` است."

msgid "Exception raised for errors that are related to the database. This serves as the base exception for several types of database errors. It is only raised implicitly through the specialised subclasses. ``DatabaseError`` is a subclass of :exc:`Error`."
msgstr "استثنایی که برای خطاهای مرتبط با پایگاه داده پرتاب می‌شود. این استثنا به‌عنوان استثنای پایه برای چندین نوع از خطاهای پایگاه داده عمل می‌کند. این استثنا تنها به‌طور ضمنی از طریق زیرکلاس‌های تخصصی پرتاب می‌شود. ``DatabaseError`` یک زیرکلاس از :exc:`Error` است."

msgid "Exception raised for errors caused by problems with the processed data, like numeric values out of range, and strings which are too long. ``DataError`` is a subclass of :exc:`DatabaseError`."
msgstr "استثنایی که برای خطاهای ناشی از مشکلات در داده‌های پردازش‌شده، مانند مقادیر عددی خارج از محدوده و رشته‌هایی که بیش از حد طولانی هستند، پرتاب می‌شود. ``DataError`` زیرکلاسی از :exc:`DatabaseError` است."

msgid "Exception raised for errors that are related to the database's operation, and not necessarily under the control of the programmer. For example, the database path is not found, or a transaction could not be processed. ``OperationalError`` is a subclass of :exc:`DatabaseError`."
msgstr "استثنایی که برای خطاهایی پرتاب می‌شود که به عملیات پایگاه داده مرتبط هستند و لزوماً تحت کنترل برنامه‌نویس نیستند. برای مثال، مسیر پایگاه داده پیدا نشود یا تراکنشی قابل پردازش نباشد. ``OperationalError`` زیرکلاسی از :exc:`DatabaseError` است."

msgid "Exception raised when the relational integrity of the database is affected, e.g. a foreign key check fails.  It is a subclass of :exc:`DatabaseError`."
msgstr "استثنایی که هنگامی پرتاب می‌شود که یکپارچگی رابطه‌ای پایگاه داده تحت تأثیر قرار بگیرد، برای مثال وقتی بررسی کلید خارجی ناموفق باشد. این استثنا یک زیرکلاس از :exc:`DatabaseError` است."

msgid "Exception raised when SQLite encounters an internal error. If this is raised, it may indicate that there is a problem with the runtime SQLite library. ``InternalError`` is a subclass of :exc:`DatabaseError`."
msgstr "استثنایی که هنگام بروز خطای داخلی در SQLite پرتاب می‌شود. اگر این استثنا پرتاب شود، ممکن است نشان‌دهنده‌ی وجود مشکل در کتابخانه‌ی ران‌تایم SQLite باشد. ``InternalError`` زیرکلاسی از :exc:`DatabaseError` است."

msgid "Exception raised for :mod:`!sqlite3` API programming errors, for example supplying the wrong number of bindings to a query, or trying to operate on a closed :class:`Connection`. ``ProgrammingError`` is a subclass of :exc:`DatabaseError`."
msgstr "استثنایی که برای خطاهای برنامه‌نویسی در API :mod:`!sqlite3` پرتاب می‌شود، برای مثال ارائه تعداد نادرست مقیدسازی‌ها به یک کوئری، یا تلاش برای انجام عملیات روی یک :class:`Connection` بسته. ``ProgrammingError`` زیرکلاسی از :exc:`DatabaseError` است."

msgid "Exception raised in case a method or database API is not supported by the underlying SQLite library. For example, setting *deterministic* to ``True`` in :meth:`~Connection.create_function`, if the underlying SQLite library does not support deterministic functions. ``NotSupportedError`` is a subclass of :exc:`DatabaseError`."
msgstr "استثنایی که در صورتی پرتاب می‌شود که یک متد یا API پایگاه داده توسط کتابخانه SQLite زیرین پشتیبانی نشود. برای مثال، تنظیم *deterministic* روی ``True`` در :meth:`~Connection.create_function`، در صورتی که کتابخانه SQLite زیرین از توابع قطعی پشتیبانی نکند. ``NotSupportedError`` زیرکلاسی از :exc:`DatabaseError` است."

msgid "SQLite and Python types"
msgstr "نوع‌های SQLite و پایتون"

msgid "SQLite natively supports the following types: ``NULL``, ``INTEGER``, ``REAL``, ``TEXT``, ``BLOB``."
msgstr "SQLite به‌صورت بومی از انواع زیر پشتیبانی می‌کند: ``NULL``، ``INTEGER``، ``REAL``، ``TEXT``، ``BLOB``."

msgid "The following Python types can thus be sent to SQLite without any problem:"
msgstr "بنابراین می‌توان انواع پایتون زیر را بدون هیچ مشکلی به SQLite ارسال کرد:"

msgid "Python type"
msgstr "نوع پایتون"

msgid "SQLite type"
msgstr "نوع SQLite"

msgid "``None``"
msgstr "``None``"

msgid "``NULL``"
msgstr "``NULL``"

msgid ":class:`int`"
msgstr ":class:`int`"

msgid "``INTEGER``"
msgstr "``INTEGER``"

msgid ":class:`float`"
msgstr ":class:`float`"

msgid "``REAL``"
msgstr "``REAL``"

msgid ":class:`str`"
msgstr ":class:`str`"

msgid "``TEXT``"
msgstr "``TEXT``"

msgid ":class:`bytes`"
msgstr ":class:`bytes`"

msgid "``BLOB``"
msgstr "``BLOB``"

msgid "This is how SQLite types are converted to Python types by default:"
msgstr "انواع SQLite به‌صورت پیش‌فرض این‌گونه به انواع پایتون تبدیل می‌شوند:"

msgid "depends on :attr:`~Connection.text_factory`, :class:`str` by default"
msgstr "به :attr:`~Connection.text_factory` بستگی دارد، به‌طور پیش‌فرض :class:`str`"

msgid "The type system of the :mod:`!sqlite3` module is extensible in two ways: you can store additional Python types in an SQLite database via :ref:`object adapters <sqlite3-adapters>`, and you can let the :mod:`!sqlite3` module convert SQLite types to Python types via :ref:`converters <sqlite3-converters>`."
msgstr "سیستم نوع ماژول :mod:`!sqlite3` به ۲ روش قابل‌گسترش است: شما می‌توانید انواع اضافی پایتون را از طریق :ref:`آداپتورهای شیء (object adapters) <sqlite3-adapters>` در یک پایگاه‌داده‌ی SQLite ذخیره کنید، و می‌توانید به ماژول :mod:`!sqlite3` اجازه دهید تا انواع SQLite را از طریق :ref:`مبدل‌ها (converters) <sqlite3-converters>` به انواع پایتون تبدیل کند."

msgid "Default adapters and converters (deprecated)"
msgstr "سازگارکننده‌ها و مبدل‌های پیش‌فرض (منسوخ)"

msgid "The default adapters and converters are deprecated as of Python 3.12. Instead, use the :ref:`sqlite3-adapter-converter-recipes` and tailor them to your needs."
msgstr "آداپتورها و مبدل‌های پیش‌فرض از پایتون 3.12 منسوخ شده‌اند. در عوض، از :ref:`sqlite3-adapter-converter-recipes` استفاده کنید و آن‌ها را متناسب با نیازهای خود تنظیم کنید."

msgid "The deprecated default adapters and converters consist of:"
msgstr "آداپتورها و مبدل‌های پیش‌فرض منسوخ‌شده عبارت‌اند از:"

msgid "An adapter for :class:`datetime.date` objects to :class:`strings <str>` in `ISO 8601`_ format."
msgstr "آداپتوری برای تبدیل اشیای :class:`datetime.date` به :class:`strings <str>` در قالب `ISO 8601`_."

msgid "An adapter for :class:`datetime.datetime` objects to strings in ISO 8601 format."
msgstr "یک آداپتور (adapter) برای تبدیل اشیای :class:`datetime.datetime` به رشته‌هایی در قالب ISO 8601."

msgid "A converter for :ref:`declared <sqlite3-converters>` \"date\" types to :class:`datetime.date` objects."
msgstr "مبدلی برای تبدیل انواع \"date\" :ref:`اعلام‌شده <sqlite3-converters>` به اشیای :class:`datetime.date`."

msgid "A converter for declared \"timestamp\" types to :class:`datetime.datetime` objects. Fractional parts will be truncated to 6 digits (microsecond precision)."
msgstr "مبدلی برای تبدیل انواع «timestamp» اعلام‌شده به اشیای :class:`datetime.datetime`. بخش‌های کسری به ۶ رقم کوتاه می‌شوند (دقت میکروثانیه)."

msgid "The default \"timestamp\" converter ignores UTC offsets in the database and always returns a naive :class:`datetime.datetime` object. To preserve UTC offsets in timestamps, either leave converters disabled, or register an offset-aware converter with :func:`register_converter`."
msgstr "مبدل پیش‌فرض \"timestamp\" انحراف‌های UTC را در پایگاه داده نادیده می‌گیرد و همیشه یک شیء :class:`datetime.datetime` ساده برمی‌گرداند. برای حفظ انحراف‌های UTC در timestampها، یا مبدل‌ها را غیرفعال نگه دارید، یا یک مبدل آگاه از انحراف را با :func:`register_converter` ثبت کنید."

msgid "Command-line interface"
msgstr "رابط خط فرمان"

msgid "The :mod:`!sqlite3` module can be invoked as a script, using the interpreter's :option:`-m` switch, in order to provide a simple SQLite shell. The argument signature is as follows::"
msgstr "می‌توان ماژول :mod:`!sqlite3` را به‌عنوان یک اسکریپت، با استفاده از سوییچ :option:`-m` مفسر، فراخوانی کرد تا یک پوسته ساده SQLite فراهم شود. امضای آرگومان به صورت زیر است::"

msgid "python -m sqlite3 [-h] [-v] [filename] [sql]"
msgstr "python -m sqlite3 [-h] [-v] [filename] [sql]"

msgid "Type ``.quit`` or CTRL-D to exit the shell."
msgstr "برای خروج از پوسته، ``.quit`` یا CTRL-D را وارد کنید."

msgid "Print CLI help."
msgstr "چاپ راهنمای CLI."

msgid "Print underlying SQLite library version."
msgstr "نسخه‌ی کتابخانه‌ی SQLite زیرین را چاپ می‌کند."

msgid "How-to guides"
msgstr "راهنماهای چگونگی"

msgid "How to use placeholders to bind values in SQL queries"
msgstr "چگونه از جای‌نگهدارها (placeholders) برای مقیدسازی مقادیر در پرس‌وجوهای SQL استفاده کنیم"

msgid "SQL operations usually need to use values from Python variables. However, beware of using Python's string operations to assemble queries, as they are vulnerable to `SQL injection attacks`_. For example, an attacker can simply close the single quote and inject ``OR TRUE`` to select all rows::"
msgstr "عملیات‌های SQL معمولاً به استفاده از مقادیر متغیرهای پایتون نیاز دارند. با این حال، از استفاده از عملیات رشته‌ای پایتون برای ساخت پرس‌وجوها برحذر باشید، زیرا در برابر `حملات تزریق SQL`_ آسیب‌پذیرند. برای مثال، یک مهاجم می‌تواند به‌سادگی علامت نقل‌قول تکی را ببندد و ``OR TRUE`` را تزریق کند تا تمام ردیف‌ها انتخاب شوند::"

msgid ""
">>> # Never do this -- insecure!\n"
">>> symbol = input()\n"
"' OR TRUE; --\n"
">>> sql = \"SELECT * FROM stocks WHERE symbol = '%s'\" % symbol\n"
">>> print(sql)\n"
"SELECT * FROM stocks WHERE symbol = '' OR TRUE; --'\n"
">>> cur.execute(sql)"
msgstr ""
">>> # Never do this -- insecure!\n"
">>> symbol = input()\n"
"' OR TRUE; --\n"
">>> sql = \"SELECT * FROM stocks WHERE symbol = '%s'\" % symbol\n"
">>> print(sql)\n"
"SELECT * FROM stocks WHERE symbol = '' OR TRUE; --'\n"
">>> cur.execute(sql)"

msgid "Instead, use the DB-API's parameter substitution. To insert a variable into a query string, use a placeholder in the string, and substitute the actual values into the query by providing them as a :class:`tuple` of values to the second argument of the cursor's :meth:`~Cursor.execute` method."
msgstr "در عوض، از جای‌گزینی پارامترِ DB-API استفاده کنید. برای درج یک متغیر در رشته‌ی پرس‌وجو، از یک جای‌نگهدار در رشته استفاده کنید و مقادیر واقعی را با ارائه آن‌ها به‌صورت یک :class:`tuple` از مقادیر به آرگومان دوم متد :meth:`~Cursor.execute` نشانگر، در پرس‌وجو جای‌گزین کنید."

msgid "An SQL statement may use one of two kinds of placeholders: question marks (qmark style) or named placeholders (named style). For the qmark style, *parameters* must be a :term:`sequence` whose length must match the number of placeholders, or a :exc:`ProgrammingError` is raised. For the named style, *parameters* must be an instance of a :class:`dict` (or a subclass), which must contain keys for all named parameters; any extra items are ignored. Here's an example of both styles:"
msgstr "یک دستور SQL ممکن است از یکی از دو نوع جای‌نگهدار استفاده کند: علامت‌های سؤال (سبک qmark) یا جای‌نگهدارهای نام‌دار (سبک named). برای سبک qmark، *parameters* باید یک :term:`sequence` باشد که طول آن باید با تعداد جای‌نگهدارها برابر باشد، در غیر این صورت یک :exc:`ProgrammingError` پرتاب می‌شود. برای سبک named، *parameters* باید نمونه‌ای از :class:`dict` (یا یک زیرکلاس) باشد که باید شامل کلیدهایی برای همه‌ی پارامترهای نام‌دار باشد؛ هر آیتم اضافی نادیده گرفته می‌شود. در ادامه مثالی از هر دو سبک آمده است:"

msgid ""
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.execute(\"CREATE TABLE lang(name, first_appeared)\")\n"
"\n"
"# This is the named style used with executemany():\n"
"data = (\n"
"    {\"name\": \"C\", \"year\": 1972},\n"
"    {\"name\": \"Fortran\", \"year\": 1957},\n"
"    {\"name\": \"Python\", \"year\": 1991},\n"
"    {\"name\": \"Go\", \"year\": 2009},\n"
")\n"
"cur.executemany(\"INSERT INTO lang VALUES(:name, :year)\", data)\n"
"\n"
"# This is the qmark style used in a SELECT query:\n"
"params = (1972,)\n"
"cur.execute(\"SELECT * FROM lang WHERE first_appeared = ?\", params)\n"
"print(cur.fetchall())\n"
"con.close()"
msgstr ""
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.execute(\"CREATE TABLE lang(name, first_appeared)\")\n"
"\n"
"# This is the named style used with executemany():\n"
"data = (\n"
"    {\"name\": \"C\", \"year\": 1972},\n"
"    {\"name\": \"Fortran\", \"year\": 1957},\n"
"    {\"name\": \"Python\", \"year\": 1991},\n"
"    {\"name\": \"Go\", \"year\": 2009},\n"
")\n"
"cur.executemany(\"INSERT INTO lang VALUES(:name, :year)\", data)\n"
"\n"
"# This is the qmark style used in a SELECT query:\n"
"params = (1972,)\n"
"cur.execute(\"SELECT * FROM lang WHERE first_appeared = ?\", params)\n"
"print(cur.fetchall())\n"
"con.close()"

msgid ":pep:`249` numeric placeholders are *not* supported. If used, they will be interpreted as named placeholders."
msgstr "از جای‌نگه‌دارهای عددی :pep:`249` پشتیبانی *نمی‌شود*. در صورت استفاده، به‌عنوان جای‌نگه‌دارهای نام‌دار تفسیر خواهند شد."

msgid "How to adapt custom Python types to SQLite values"
msgstr "چگونگی تطبیق انواع سفارشی پایتون با مقادیر SQLite"

msgid "SQLite supports only a limited set of data types natively. To store custom Python types in SQLite databases, *adapt* them to one of the :ref:`Python types SQLite natively understands <sqlite3-types>`."
msgstr "SQLite تنها از مجموعه‌ای محدود از انواع داده به‌صورت بومی پشتیبانی می‌کند. برای ذخیره‌ی انواع پایتونی سفارشی در پایگاه‌های داده‌ی SQLite، آن‌ها را با یکی از :ref:`انواع پایتونی که SQLite به‌صورت بومی می‌شناسد <sqlite3-types>` *سازگار* کنید."

msgid "There are two ways to adapt Python objects to SQLite types: letting your object adapt itself, or using an *adapter callable*. The latter will take precedence above the former. For a library that exports a custom type, it may make sense to enable that type to adapt itself. As an application developer, it may make more sense to take direct control by registering custom adapter functions."
msgstr "دو روش برای تطبیق اشیای پایتون با انواع SQLite وجود دارد: اینکه بگذارید شیء شما خودش را تطبیق دهد، یا استفاده از یک *فراخوانی‌پذیر تطبیق‌دهنده (adapter callable)*. دومی بر اولی تقدم خواهد داشت. برای کتابخانه‌ای که یک نوع سفارشی اکسپورت می‌کند، ممکن است منطقی باشد که آن نوع بتواند خودش را تطبیق دهد. به‌عنوان توسعه‌دهنده‌ی برنامه‌ی کاربردی، ممکن است منطقی‌تر باشد که با ثبت توابع تطبیق‌دهنده‌ی سفارشی، کنترل مستقیم را در دست بگیرید."

msgid "How to write adaptable objects"
msgstr "چگونه اشیای سازگارپذیر بنویسیم"

msgid "Suppose we have a :class:`!Point` class that represents a pair of coordinates, ``x`` and ``y``, in a Cartesian coordinate system. The coordinate pair will be stored as a text string in the database, using a semicolon to separate the coordinates. This can be implemented by adding a ``__conform__(self, protocol)`` method which returns the adapted value. The object passed to *protocol* will be of type :class:`PrepareProtocol`."
msgstr "فرض کنید یک کلاس :class:`!Point` داریم که یک جفت مختصات، ``x`` و ``y``، را در یک دستگاه مختصات دکارتی نشان می‌دهد. جفت مختصات به‌صورت یک رشته متنی در پایگاه داده ذخیره خواهد شد و برای جداسازی مختصات از نقطه‌ویرگول استفاده می‌شود. این کار را می‌توان با افزودن یک متد ``__conform__(self, protocol)`` پیاده‌سازی کرد که مقدار تطبیق‌یافته را برمی‌گرداند. شیء منتقل‌شده به *protocol* از نوع :class:`PrepareProtocol` خواهد بود."

msgid ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x, self.y = x, y\n"
"\n"
"    def __conform__(self, protocol):\n"
"        if protocol is sqlite3.PrepareProtocol:\n"
"            return f\"{self.x};{self.y}\"\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.cursor()\n"
"\n"
"cur.execute(\"SELECT ?\", (Point(4.0, -3.2),))\n"
"print(cur.fetchone()[0])\n"
"con.close()"
msgstr ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x, self.y = x, y\n"
"\n"
"    def __conform__(self, protocol):\n"
"        if protocol is sqlite3.PrepareProtocol:\n"
"            return f\"{self.x};{self.y}\"\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.cursor()\n"
"\n"
"cur.execute(\"SELECT ?\", (Point(4.0, -3.2),))\n"
"print(cur.fetchone()[0])\n"
"con.close()"

msgid "How to register adapter callables"
msgstr "چگونه موارد فراخوانی‌پذیر آداپتور را ثبت کنید"

msgid "The other possibility is to create a function that converts the Python object to an SQLite-compatible type. This function can then be registered using :func:`register_adapter`."
msgstr "امکان دیگر، ساخت تابعی است که شیء پایتون را به نوعی سازگار با SQLite تبدیل می‌کند. سپس می‌توانید این تابع را با استفاده از :func:`register_adapter` ثبت کنید."

msgid ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x, self.y = x, y\n"
"\n"
"def adapt_point(point):\n"
"    return f\"{point.x};{point.y}\"\n"
"\n"
"sqlite3.register_adapter(Point, adapt_point)\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.cursor()\n"
"\n"
"cur.execute(\"SELECT ?\", (Point(1.0, 2.5),))\n"
"print(cur.fetchone()[0])\n"
"con.close()"
msgstr ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x, self.y = x, y\n"
"\n"
"def adapt_point(point):\n"
"    return f\"{point.x};{point.y}\"\n"
"\n"
"sqlite3.register_adapter(Point, adapt_point)\n"
"\n"
"con = sqlite3.connect(\":memory:\")\n"
"cur = con.cursor()\n"
"\n"
"cur.execute(\"SELECT ?\", (Point(1.0, 2.5),))\n"
"print(cur.fetchone()[0])\n"
"con.close()"

msgid "How to convert SQLite values to custom Python types"
msgstr "چگونه مقادیر SQLite را به انواع سفارشی پایتون تبدیل کنیم"

msgid "Writing an adapter lets you convert *from* custom Python types *to* SQLite values. To be able to convert *from* SQLite values *to* custom Python types, we use *converters*."
msgstr "نوشتن یک آداپتور امکان تبدیل *از* انواع سفارشی پایتون *به* مقادیر SQLite را به شما می‌دهد. برای توانایی تبدیل *از* مقادیر SQLite *به* انواع سفارشی پایتون، از *مبدل‌ها* استفاده می‌کنیم."

msgid "Let's go back to the :class:`!Point` class. We stored the x and y coordinates separated via semicolons as strings in SQLite."
msgstr "بیایید به کلاس :class:`!Point` بازگردیم. ما مختصات x و y را به‌صورت رشته‌هایی که با نقطه‌ویرگول از یکدیگر جدا شده‌اند، در SQLite ذخیره کردیم."

msgid "First, we'll define a converter function that accepts the string as a parameter and constructs a :class:`!Point` object from it."
msgstr "ابتدا، یک تابع تبدیل‌کننده تعریف می‌کنیم که رشته را به‌عنوان پارامتر می‌پذیرد و از روی آن یک شیء :class:`!Point` می‌سازد."

msgid "Converter functions are **always** passed a :class:`bytes` object, no matter the underlying SQLite data type."
msgstr "توابع مبدل **همیشه** یک شیء :class:`bytes` دریافت می‌کنند، صرف‌نظر از نوع داده‌ی زیرین SQLite."

msgid ""
"def convert_point(s):\n"
"    x, y = map(float, s.split(b\";\"))\n"
"    return Point(x, y)"
msgstr ""
"def convert_point(s):\n"
"    x, y = map(float, s.split(b\";\"))\n"
"    return Point(x, y)"

msgid "We now need to tell :mod:`!sqlite3` when it should convert a given SQLite value. This is done when connecting to a database, using the *detect_types* parameter of :func:`connect`. There are three options:"
msgstr "اکنون باید به :mod:`!sqlite3` بگوییم که چه زمانی باید یک مقدار SQLite مشخص را تبدیل کند. این کار هنگام اتصال به یک پایگاه داده، با استفاده از پارامتر *detect_types* تابع :func:`connect` انجام می‌شود. سه گزینه وجود دارد:"

msgid "Implicit: set *detect_types* to :const:`PARSE_DECLTYPES`"
msgstr "ضمنی: *detect_types* را روی :const:`PARSE_DECLTYPES` تنظیم کنید"

msgid "Explicit: set *detect_types* to :const:`PARSE_COLNAMES`"
msgstr "صریح: *detect_types* را روی :const:`PARSE_COLNAMES` تنظیم کنید"

msgid "Both: set *detect_types* to ``sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES``. Column names take precedence over declared types."
msgstr "هر دو: *detect_types* را روی ``sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES`` تنظیم کنید. نام ستون‌ها بر انواع اعلام‌شده اولویت دارند."

msgid "The following example illustrates the implicit and explicit approaches:"
msgstr "مثال زیر رویکردهای ضمنی و صریح را نشان می‌دهد:"

msgid ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x, self.y = x, y\n"
"\n"
"    def __repr__(self):\n"
"        return f\"Point({self.x}, {self.y})\"\n"
"\n"
"def adapt_point(point):\n"
"    return f\"{point.x};{point.y}\"\n"
"\n"
"def convert_point(s):\n"
"    x, y = list(map(float, s.split(b\";\")))\n"
"    return Point(x, y)\n"
"\n"
"# Register the adapter and converter\n"
"sqlite3.register_adapter(Point, adapt_point)\n"
"sqlite3.register_converter(\"point\", convert_point)\n"
"\n"
"# 1) Parse using declared types\n"
"p = Point(4.0, -3.2)\n"
"con = sqlite3.connect(\":memory:\", detect_types=sqlite3.PARSE_DECLTYPES)\n"
"cur = con.execute(\"CREATE TABLE test(p point)\")\n"
"\n"
"cur.execute(\"INSERT INTO test(p) VALUES(?)\", (p,))\n"
"cur.execute(\"SELECT p FROM test\")\n"
"print(\"with declared types:\", cur.fetchone()[0])\n"
"cur.close()\n"
"con.close()\n"
"\n"
"# 2) Parse using column names\n"
"con = sqlite3.connect(\":memory:\", detect_types=sqlite3.PARSE_COLNAMES)\n"
"cur = con.execute(\"CREATE TABLE test(p)\")\n"
"\n"
"cur.execute(\"INSERT INTO test(p) VALUES(?)\", (p,))\n"
"cur.execute('SELECT p AS \"p [point]\" FROM test')\n"
"print(\"with column names:\", cur.fetchone()[0])\n"
"cur.close()\n"
"con.close()"
msgstr ""
"class Point:\n"
"    def __init__(self, x, y):\n"
"        self.x, self.y = x, y\n"
"\n"
"    def __repr__(self):\n"
"        return f\"Point({self.x}, {self.y})\"\n"
"\n"
"def adapt_point(point):\n"
"    return f\"{point.x};{point.y}\"\n"
"\n"
"def convert_point(s):\n"
"    x, y = list(map(float, s.split(b\";\")))\n"
"    return Point(x, y)\n"
"\n"
"# Register the adapter and converter\n"
"sqlite3.register_adapter(Point, adapt_point)\n"
"sqlite3.register_converter(\"point\", convert_point)\n"
"\n"
"# 1) Parse using declared types\n"
"p = Point(4.0, -3.2)\n"
"con = sqlite3.connect(\":memory:\", detect_types=sqlite3.PARSE_DECLTYPES)\n"
"cur = con.execute(\"CREATE TABLE test(p point)\")\n"
"\n"
"cur.execute(\"INSERT INTO test(p) VALUES(?)\", (p,))\n"
"cur.execute(\"SELECT p FROM test\")\n"
"print(\"with declared types:\", cur.fetchone()[0])\n"
"cur.close()\n"
"con.close()\n"
"\n"
"# 2) Parse using column names\n"
"con = sqlite3.connect(\":memory:\", detect_types=sqlite3.PARSE_COLNAMES)\n"
"cur = con.execute(\"CREATE TABLE test(p)\")\n"
"\n"
"cur.execute(\"INSERT INTO test(p) VALUES(?)\", (p,))\n"
"cur.execute('SELECT p AS \"p [point]\" FROM test')\n"
"print(\"with column names:\", cur.fetchone()[0])\n"
"cur.close()\n"
"con.close()"

msgid "Adapter and converter recipes"
msgstr "دستورپخت‌های آداپتور و مبدل"

msgid "This section shows recipes for common adapters and converters."
msgstr "این بخش دستورالعمل‌هایی برای آداپتورها و مبدل‌های رایج ارائه می‌دهد."

msgid ""
"import datetime as dt\n"
"import sqlite3\n"
"\n"
"def adapt_date_iso(val):\n"
"    \"\"\"Adapt datetime.date to ISO 8601 date.\"\"\"\n"
"    return val.isoformat()\n"
"\n"
"def adapt_datetime_iso(val):\n"
"    \"\"\"Adapt datetime.datetime to timezone-naive ISO 8601 date.\"\"\"\n"
"    return val.replace(tzinfo=None).isoformat()\n"
"\n"
"def adapt_datetime_epoch(val):\n"
"    \"\"\"Adapt datetime.datetime to Unix timestamp.\"\"\"\n"
"    return int(val.timestamp())\n"
"\n"
"sqlite3.register_adapter(dt.date, adapt_date_iso)\n"
"sqlite3.register_adapter(dt.datetime, adapt_datetime_iso)\n"
"sqlite3.register_adapter(dt.datetime, adapt_datetime_epoch)\n"
"\n"
"def convert_date(val):\n"
"    \"\"\"Convert ISO 8601 date to datetime.date object.\"\"\"\n"
"    return dt.date.fromisoformat(val.decode())\n"
"\n"
"def convert_datetime(val):\n"
"    \"\"\"Convert ISO 8601 datetime to datetime.datetime object.\"\"\"\n"
"    return dt.datetime.fromisoformat(val.decode())\n"
"\n"
"def convert_timestamp(val):\n"
"    \"\"\"Convert Unix epoch timestamp to datetime.datetime object.\"\"\"\n"
"    return dt.datetime.fromtimestamp(int(val))\n"
"\n"
"sqlite3.register_converter(\"date\", convert_date)\n"
"sqlite3.register_converter(\"datetime\", convert_datetime)\n"
"sqlite3.register_converter(\"timestamp\", convert_timestamp)"
msgstr ""
"import datetime as dt\n"
"import sqlite3\n"
"\n"
"def adapt_date_iso(val):\n"
"    \"\"\"Adapt datetime.date to ISO 8601 date.\"\"\"\n"
"    return val.isoformat()\n"
"\n"
"def adapt_datetime_iso(val):\n"
"    \"\"\"Adapt datetime.datetime to timezone-naive ISO 8601 date.\"\"\"\n"
"    return val.replace(tzinfo=None).isoformat()\n"
"\n"
"def adapt_datetime_epoch(val):\n"
"    \"\"\"Adapt datetime.datetime to Unix timestamp.\"\"\"\n"
"    return int(val.timestamp())\n"
"\n"
"sqlite3.register_adapter(dt.date, adapt_date_iso)\n"
"sqlite3.register_adapter(dt.datetime, adapt_datetime_iso)\n"
"sqlite3.register_adapter(dt.datetime, adapt_datetime_epoch)\n"
"\n"
"def convert_date(val):\n"
"    \"\"\"Convert ISO 8601 date to datetime.date object.\"\"\"\n"
"    return dt.date.fromisoformat(val.decode())\n"
"\n"
"def convert_datetime(val):\n"
"    \"\"\"Convert ISO 8601 datetime to datetime.datetime object.\"\"\"\n"
"    return dt.datetime.fromisoformat(val.decode())\n"
"\n"
"def convert_timestamp(val):\n"
"    \"\"\"Convert Unix epoch timestamp to datetime.datetime object.\"\"\"\n"
"    return dt.datetime.fromtimestamp(int(val))\n"
"\n"
"sqlite3.register_converter(\"date\", convert_date)\n"
"sqlite3.register_converter(\"datetime\", convert_datetime)\n"
"sqlite3.register_converter(\"timestamp\", convert_timestamp)"

msgid "How to use connection shortcut methods"
msgstr "نحوه استفاده از متدهای میان‌بر اتصال"

msgid "Using the :meth:`~Connection.execute`, :meth:`~Connection.executemany`, and :meth:`~Connection.executescript` methods of the :class:`Connection` class, your code can be written more concisely because you don't have to create the (often superfluous) :class:`Cursor` objects explicitly. Instead, the :class:`Cursor` objects are created implicitly and these shortcut methods return the cursor objects. This way, you can execute a ``SELECT`` statement and iterate over it directly using only a single call on the :class:`Connection` object."
msgstr "با استفاده از متدهای :meth:`~Connection.execute`، :meth:`~Connection.executemany` و :meth:`~Connection.executescript` کلاس :class:`Connection`، می‌توانید کد خود را مختصرتر بنویسید، زیرا نیازی نیست اشیای :class:`Cursor` را (که اغلب غیرضروری هستند) به‌صورت صریح ایجاد کنید. در عوض، اشیای :class:`Cursor` به‌صورت ضمنی ایجاد می‌شوند و این متدهای میان‌بر اشیای cursor را برمی‌گردانند. به این ترتیب، می‌توانید یک دستور ``SELECT`` را اجرا کرده و تنها با یک فراخوانی روی شیء :class:`Connection`، مستقیماً آن را پیمایش کنید."

msgid ""
"# Create and fill the table.\n"
"con = sqlite3.connect(\":memory:\")\n"
"con.execute(\"CREATE TABLE lang(name, first_appeared)\")\n"
"data = [\n"
"    (\"C++\", 1985),\n"
"    (\"Objective-C\", 1984),\n"
"]\n"
"con.executemany(\"INSERT INTO lang(name, first_appeared) VALUES(?, ?)\", data)\n"
"\n"
"# Print the table contents\n"
"for row in con.execute(\"SELECT name, first_appeared FROM lang\"):\n"
"    print(row)\n"
"\n"
"print(\"I just deleted\", con.execute(\"DELETE FROM lang\").rowcount, \"rows\")\n"
"\n"
"# close() is not a shortcut method and it's not called automatically;\n"
"# the connection object should be closed manually\n"
"con.close()"
msgstr ""
"# Create and fill the table.\n"
"con = sqlite3.connect(\":memory:\")\n"
"con.execute(\"CREATE TABLE lang(name, first_appeared)\")\n"
"data = [\n"
"    (\"C++\", 1985),\n"
"    (\"Objective-C\", 1984),\n"
"]\n"
"con.executemany(\"INSERT INTO lang(name, first_appeared) VALUES(?, ?)\", data)\n"
"\n"
"# Print the table contents\n"
"for row in con.execute(\"SELECT name, first_appeared FROM lang\"):\n"
"    print(row)\n"
"\n"
"print(\"I just deleted\", con.execute(\"DELETE FROM lang\").rowcount, \"rows\")\n"
"\n"
"# close() is not a shortcut method and it's not called automatically;\n"
"# the connection object should be closed manually\n"
"con.close()"

msgid "How to use the connection context manager"
msgstr "نحوه استفاده از مدیر زمینه اتصال"

msgid "A :class:`Connection` object can be used as a context manager that automatically commits or rolls back open transactions when leaving the body of the context manager. If the body of the :keyword:`with` statement finishes without exceptions, the transaction is committed. If this commit fails, or if the body of the ``with`` statement raises an uncaught exception, the transaction is rolled back. If :attr:`~Connection.autocommit` is ``False``, a new transaction is implicitly opened after committing or rolling back."
msgstr "یک شیء :class:`Connection` می‌تواند به‌عنوان یک مدیر زمینه استفاده شود که هنگام خروج از بدنه‌ی مدیر زمینه، تراکنش‌های باز را به‌طور خودکار ثبت یا بازگردانی می‌کند. اگر بدنه‌ی دستور :keyword:`with` بدون استثنا به پایان برسد، تراکنش ثبت می‌شود. اگر این ثبت ناموفق باشد، یا اگر بدنه‌ی دستور ``with`` یک استثنای گرفته‌نشده پرتاب کند، تراکنش بازگردانی می‌شود. اگر :attr:`~Connection.autocommit` برابر ``False`` باشد، پس از ثبت یا بازگردانی، یک تراکنش جدید به‌طور ضمنی باز می‌شود."

msgid "If there is no open transaction upon leaving the body of the ``with`` statement, or if :attr:`~Connection.autocommit` is ``True``, the context manager does nothing."
msgstr "اگر هنگام خروج از بدنه‌ی دستور ``with`` هیچ تراکنش بازی وجود نداشته باشد، یا اگر :attr:`~Connection.autocommit` برابر ``True`` باشد، مدیر زمینه هیچ کاری انجام نمی‌دهد."

msgid "The context manager neither implicitly opens a new transaction nor closes the connection. If you need a closing context manager, consider using :meth:`contextlib.closing`."
msgstr "این مدیر زمینه نه به‌طور ضمنی تراکنش جدیدی را باز می‌کند و نه اتصال را می‌بندد. اگر به یک مدیر زمینه برای بستن نیاز دارید، استفاده از :meth:`contextlib.closing` را در نظر بگیرید."

msgid ""
"con = sqlite3.connect(\":memory:\")\n"
"con.execute(\"CREATE TABLE lang(id INTEGER PRIMARY KEY, name VARCHAR UNIQUE)\")\n"
"\n"
"# Successful, con.commit() is called automatically afterwards\n"
"with con:\n"
"    con.execute(\"INSERT INTO lang(name) VALUES(?)\", (\"Python\",))\n"
"\n"
"# con.rollback() is called after the with block finishes with an exception,\n"
"# the exception is still raised and must be caught\n"
"try:\n"
"    with con:\n"
"        con.execute(\"INSERT INTO lang(name) VALUES(?)\", (\"Python\",))\n"
"except sqlite3.IntegrityError:\n"
"    print(\"couldn't add Python twice\")\n"
"\n"
"# Connection object used as context manager only commits or rollbacks transactions,\n"
"# so the connection object should be closed manually\n"
"con.close()"
msgstr ""
"con = sqlite3.connect(\":memory:\")\n"
"con.execute(\"CREATE TABLE lang(id INTEGER PRIMARY KEY, name VARCHAR UNIQUE)\")\n"
"\n"
"# Successful, con.commit() is called automatically afterwards\n"
"with con:\n"
"    con.execute(\"INSERT INTO lang(name) VALUES(?)\", (\"Python\",))\n"
"\n"
"# con.rollback() is called after the with block finishes with an exception,\n"
"# the exception is still raised and must be caught\n"
"try:\n"
"    with con:\n"
"        con.execute(\"INSERT INTO lang(name) VALUES(?)\", (\"Python\",))\n"
"except sqlite3.IntegrityError:\n"
"    print(\"couldn't add Python twice\")\n"
"\n"
"# Connection object used as context manager only commits or rollbacks transactions,\n"
"# so the connection object should be closed manually\n"
"con.close()"

msgid "How to work with SQLite URIs"
msgstr "نحوه کار با URIهای SQLite"

msgid "Some useful URI tricks include:"
msgstr "برخی ترفندهای مفید URI عبارتند از:"

msgid "Open a database in read-only mode:"
msgstr "باز کردن یک پایگاه داده در حالت فقط‌خواندنی:"

msgid ""
">>> con = sqlite3.connect(\"file:tutorial.db?mode=ro\", uri=True)\n"
">>> con.execute(\"CREATE TABLE readonly(data)\")\n"
"Traceback (most recent call last):\n"
"OperationalError: attempt to write a readonly database\n"
">>> con.close()"
msgstr ""
">>> con = sqlite3.connect(\"file:tutorial.db?mode=ro\", uri=True)\n"
">>> con.execute(\"CREATE TABLE readonly(data)\")\n"
"Traceback (most recent call last):\n"
"OperationalError: attempt to write a readonly database\n"
">>> con.close()"

msgid "Do not implicitly create a new database file if it does not already exist; will raise :exc:`~sqlite3.OperationalError` if unable to create a new file:"
msgstr "اگر پرونده پایگاه داده جدید از قبل وجود نداشته باشد، به‌طور ضمنی یک پرونده پایگاه داده جدید ایجاد نمی‌شود؛ اگر امکان ایجاد پرونده جدید وجود نداشته باشد، :exc:`~sqlite3.OperationalError` پرتاب می‌شود:"

msgid ""
">>> con = sqlite3.connect(\"file:nosuchdb.db?mode=rw\", uri=True)\n"
"Traceback (most recent call last):\n"
"OperationalError: unable to open database file"
msgstr ""
">>> con = sqlite3.connect(\"file:nosuchdb.db?mode=rw\", uri=True)\n"
"Traceback (most recent call last):\n"
"OperationalError: unable to open database file"

msgid "Create a shared named in-memory database:"
msgstr "ایجاد یک پایگاه داده‌ی درون‌حافظه‌ای نام‌دار مشترک:"

msgid ""
"db = \"file:mem1?mode=memory&cache=shared\"\n"
"con1 = sqlite3.connect(db, uri=True)\n"
"con2 = sqlite3.connect(db, uri=True)\n"
"with con1:\n"
"    con1.execute(\"CREATE TABLE shared(data)\")\n"
"    con1.execute(\"INSERT INTO shared VALUES(28)\")\n"
"res = con2.execute(\"SELECT data FROM shared\")\n"
"assert res.fetchone() == (28,)\n"
"\n"
"con1.close()\n"
"con2.close()"
msgstr ""
"db = \"file:mem1?mode=memory&cache=shared\"\n"
"con1 = sqlite3.connect(db, uri=True)\n"
"con2 = sqlite3.connect(db, uri=True)\n"
"with con1:\n"
"    con1.execute(\"CREATE TABLE shared(data)\")\n"
"    con1.execute(\"INSERT INTO shared VALUES(28)\")\n"
"res = con2.execute(\"SELECT data FROM shared\")\n"
"assert res.fetchone() == (28,)\n"
"\n"
"con1.close()\n"
"con2.close()"

msgid "More information about this feature, including a list of parameters, can be found in the `SQLite URI documentation`_."
msgstr "اطلاعات بیشتر درباره این قابلیت، از جمله فهرستی از پارامترها، در `SQLite URI documentation`_ یافت می‌شود."

msgid "How to create and use row factories"
msgstr "نحوه‌ی ایجاد و استفاده از کارخانه‌های ردیف (row factories)"

msgid "By default, :mod:`!sqlite3` represents each row as a :class:`tuple`. If a :class:`!tuple` does not suit your needs, you can use the :class:`sqlite3.Row` class or a custom :attr:`~Cursor.row_factory`."
msgstr "به‌طور پیش‌فرض، :mod:`!sqlite3` هر ردیف را به‌صورت یک :class:`tuple` نمایش می‌دهد. اگر یک :class:`!tuple` نیاز شما را برآورده نمی‌کند، می‌توانید از کلاس :class:`sqlite3.Row` یا یک :attr:`~Cursor.row_factory` سفارشی استفاده کنید."

msgid "While :attr:`!row_factory` exists as an attribute both on the :class:`Cursor` and the :class:`Connection`, it is recommended to set :class:`Connection.row_factory`, so all cursors created from the connection will use the same row factory."
msgstr "اگرچه :attr:`!row_factory` به‌عنوان یک ویژگی هم در :class:`Cursor` و هم در :class:`Connection` وجود دارد، توصیه می‌شود :class:`Connection.row_factory` را تنظیم کنید تا تمام نشانگرهایی که از اتصال ایجاد می‌شوند از همان کارخانه‌ی ردیف (row factory) استفاده کنند."

msgid ":class:`!Row` provides indexed and case-insensitive named access to columns, with minimal memory overhead and performance impact over a :class:`!tuple`. To use :class:`!Row` as a row factory, assign it to the :attr:`!row_factory` attribute:"
msgstr ":class:`!Row` دسترسی اندیسی و دسترسی نامی بدون حساسیت به بزرگی و کوچکی حروف به ستون‌ها را با حداقل سربار حافظه و تأثیر بر عملکرد نسبت به یک :class:`!tuple` فراهم می‌کند. برای استفاده از :class:`!Row` به‌عنوان کارخانه‌ی ردیف (row factory)، آن را به ویژگی :attr:`!row_factory` انتساب دهید:"

msgid ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.row_factory = sqlite3.Row"
msgstr ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.row_factory = sqlite3.Row"

msgid "Queries now return :class:`!Row` objects:"
msgstr "پرس‌وجوها اکنون اشیای :class:`!Row` را برمی‌گردانند:"

msgid ""
">>> res = con.execute(\"SELECT 'Earth' AS name, 6378 AS radius\")\n"
">>> row = res.fetchone()\n"
">>> row.keys()\n"
"['name', 'radius']\n"
">>> row[0]         # Access by index.\n"
"'Earth'\n"
">>> row[\"name\"]    # Access by name.\n"
"'Earth'\n"
">>> row[\"RADIUS\"]  # Column names are case-insensitive.\n"
"6378\n"
">>> con.close()"
msgstr ""
">>> res = con.execute(\"SELECT 'Earth' AS name, 6378 AS radius\")\n"
">>> row = res.fetchone()\n"
">>> row.keys()\n"
"['name', 'radius']\n"
">>> row[0]         # Access by index.\n"
"'Earth'\n"
">>> row[\"name\"]    # Access by name.\n"
"'Earth'\n"
">>> row[\"RADIUS\"]  # Column names are case-insensitive.\n"
"6378\n"
">>> con.close()"

msgid "The ``FROM`` clause can be omitted in the ``SELECT`` statement, as in the above example. In such cases, SQLite returns a single row with columns defined by expressions, e.g. literals, with the given aliases ``expr AS alias``."
msgstr "می‌توان بند ``FROM`` را در دستور ``SELECT`` حذف کرد، همان‌طور که در مثال بالا آمده است. در این موارد، SQLite یک ردیف واحد با ستون‌های تعریف‌شده توسط عبارت‌ها، برای مثال مقادیر لفظی، با نام‌های مستعار داده‌شده به صورت ``expr AS alias`` برمی‌گرداند."

msgid "You can create a custom :attr:`~Cursor.row_factory` that returns each row as a :class:`dict`, with column names mapped to values:"
msgstr "شما می‌توانید یک :attr:`~Cursor.row_factory` سفارشی ایجاد کنید که هر ردیف را به‌صورت یک :class:`dict` برمی‌گرداند، به‌طوری که نام ستون‌ها به مقادیر نگاشته شده‌اند:"

msgid ""
"def dict_factory(cursor, row):\n"
"    fields = [column[0] for column in cursor.description]\n"
"    return {key: value for key, value in zip(fields, row)}"
msgstr ""
"def dict_factory(cursor, row):\n"
"    fields = [column[0] for column in cursor.description]\n"
"    return {key: value for key, value in zip(fields, row)}"

msgid "Using it, queries now return a :class:`!dict` instead of a :class:`!tuple`:"
msgstr "با استفاده از آن، پرس‌وجوها اکنون یک :class:`!dict` به‌جای یک :class:`!tuple` برمی‌گردانند:"

msgid ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.row_factory = dict_factory\n"
">>> for row in con.execute(\"SELECT 1 AS a, 2 AS b\"):\n"
"...     print(row)\n"
"{'a': 1, 'b': 2}\n"
">>> con.close()"
msgstr ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.row_factory = dict_factory\n"
">>> for row in con.execute(\"SELECT 1 AS a, 2 AS b\"):\n"
"...     print(row)\n"
"{'a': 1, 'b': 2}\n"
">>> con.close()"

msgid "The following row factory returns a :term:`named tuple`:"
msgstr "کارخانه ردیف (row factory) زیر یک :term:`named tuple` برمی‌گرداند:"

msgid ""
"from collections import namedtuple\n"
"\n"
"def namedtuple_factory(cursor, row):\n"
"    fields = [column[0] for column in cursor.description]\n"
"    cls = namedtuple(\"Row\", fields)\n"
"    return cls._make(row)"
msgstr ""
"from collections import namedtuple\n"
"\n"
"def namedtuple_factory(cursor, row):\n"
"    fields = [column[0] for column in cursor.description]\n"
"    cls = namedtuple(\"Row\", fields)\n"
"    return cls._make(row)"

msgid ":func:`!namedtuple_factory` can be used as follows:"
msgstr "می‌توان از :func:`!namedtuple_factory` به‌صورت زیر استفاده کرد:"

msgid ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.row_factory = namedtuple_factory\n"
">>> cur = con.execute(\"SELECT 1 AS a, 2 AS b\")\n"
">>> row = cur.fetchone()\n"
">>> row\n"
"Row(a=1, b=2)\n"
">>> row[0]  # Indexed access.\n"
"1\n"
">>> row.b   # Attribute access.\n"
"2\n"
">>> con.close()"
msgstr ""
">>> con = sqlite3.connect(\":memory:\")\n"
">>> con.row_factory = namedtuple_factory\n"
">>> cur = con.execute(\"SELECT 1 AS a, 2 AS b\")\n"
">>> row = cur.fetchone()\n"
">>> row\n"
"Row(a=1, b=2)\n"
">>> row[0]  # Indexed access.\n"
"1\n"
">>> row.b   # Attribute access.\n"
"2\n"
">>> con.close()"

msgid "With some adjustments, the above recipe can be adapted to use a :class:`~dataclasses.dataclass`, or any other custom class, instead of a :class:`~collections.namedtuple`."
msgstr "با برخی تنظیمات، می‌توان دستور بالا را برای استفاده از یک :class:`~dataclasses.dataclass` یا هر کلاس سفارشی دیگری، به‌جای یک :class:`~collections.namedtuple` تطبیق داد."

msgid "How to handle non-UTF-8 text encodings"
msgstr "نحوه‌ی مدیریت کدگذاری‌های متن غیر UTF-8"

msgid "By default, :mod:`!sqlite3` uses :class:`str` to adapt SQLite values with the ``TEXT`` data type. This works well for UTF-8 encoded text, but it might fail for other encodings and invalid UTF-8. You can use a custom :attr:`~Connection.text_factory` to handle such cases."
msgstr "به‌طور پیش‌فرض، :mod:`!sqlite3` از :class:`str` برای تطبیق مقادیر SQLite با نوع داده ``TEXT`` استفاده می‌کند. این روش برای متن‌های کدگذاری‌شده با UTF-8 به‌خوبی کار می‌کند، اما ممکن است برای کدگذاری‌های دیگر و UTF-8 نامعتبر شکست بخورد. می‌توانید از یک :attr:`~Connection.text_factory` سفارشی برای رسیدگی به چنین مواردی استفاده کنید."

msgid "Because of SQLite's `flexible typing`_, it is not uncommon to encounter table columns with the ``TEXT`` data type containing non-UTF-8 encodings, or even arbitrary data. To demonstrate, let's assume we have a database with ISO-8859-2 (Latin-2) encoded text, for example a table of Czech-English dictionary entries. Assuming we now have a :class:`Connection` instance :py:data:`!con` connected to this database, we can decode the Latin-2 encoded text using this :attr:`~Connection.text_factory`:"
msgstr "به دلیل `flexible typing`_ در SQLite، مواجه شدن با ستون‌های جدول با نوع داده ``TEXT`` که شامل کدگذاری‌های غیر UTF-8 یا حتی داده‌های دلخواه هستند، چندان غیرمعمول نیست. برای نمایش، فرض کنیم پایگاه داده‌ای با متن کدگذاری‌شده به‌صورت ISO-8859-2 (Latin-2) داریم، برای مثال جدولی از ورودی‌های فرهنگ لغت چکی-انگلیسی. با فرض اینکه اکنون یک نمونه :class:`Connection` به نام :py:data:`!con` داریم که به این پایگاه داده متصل است، می‌توانیم متن کدگذاری‌شده با Latin-2 را با استفاده از این :attr:`~Connection.text_factory` کدگشایی کنیم:"

msgid "con.text_factory = lambda data: str(data, encoding=\"latin2\")"
msgstr "con.text_factory = lambda data: str(data, encoding=\"latin2\")"

msgid "For invalid UTF-8 or arbitrary data in stored in ``TEXT`` table columns, you can use the following technique, borrowed from the :ref:`unicode-howto`:"
msgstr "برای UTF-8 نامعتبر یا داده‌های دلخواه ذخیره‌شده در ستون‌های جدول ``TEXT``، می‌توانید از روش زیر استفاده کنید، که از :ref:`unicode-howto` وام گرفته شده است:"

msgid "con.text_factory = lambda data: str(data, errors=\"surrogateescape\")"
msgstr "con.text_factory = lambda data: str(data, errors=\"surrogateescape\")"

msgid "The :mod:`!sqlite3` module API does not support strings containing surrogates."
msgstr "API ماژول :mod:`!sqlite3` از رشته‌های حاوی نویسه‌های جانشین (surrogates) پشتیبانی نمی‌کند."

msgid ":ref:`unicode-howto`"
msgstr ":ref:`unicode-howto`"

msgid "Explanation"
msgstr "توضیح"

msgid "Transaction control"
msgstr "کنترل تراکنش"

msgid ":mod:`!sqlite3` offers multiple methods of controlling whether, when and how database transactions are opened and closed. :ref:`sqlite3-transaction-control-autocommit` is recommended, while :ref:`sqlite3-transaction-control-isolation-level` retains the pre-Python 3.12 behaviour."
msgstr ":mod:`!sqlite3` روش‌های متعددی برای کنترل این‌که آیا، چه زمانی و چگونه تراکنش‌های پایگاه داده باز و بسته می‌شوند، ارائه می‌دهد. :ref:`sqlite3-transaction-control-autocommit` توصیه می‌شود، در حالی که :ref:`sqlite3-transaction-control-isolation-level` رفتار پیش از Python 3.12 را حفظ می‌کند."

msgid "Transaction control via the ``autocommit`` attribute"
msgstr "کنترل تراکنش از طریق ویژگی ``autocommit``"

msgid "The recommended way of controlling transaction behaviour is through the :attr:`Connection.autocommit` attribute, which should preferably be set using the *autocommit* parameter of :func:`connect`."
msgstr "روش توصیه‌شده برای کنترل رفتار تراکنش، از طریق ویژگی :attr:`Connection.autocommit` است که بهتر است با پارامتر *autocommit* در :func:`connect` تنظیم شود."

msgid "It is suggested to set *autocommit* to ``False``, which implies :pep:`249`-compliant transaction control. This means:"
msgstr "پیشنهاد می‌شود *autocommit* را روی ``False`` تنظیم کنید، که به معنای کنترل تراکنش مطابق :pep:`249` است. این یعنی:"

msgid ":mod:`!sqlite3` ensures that a transaction is always open, so :func:`connect`, :meth:`Connection.commit`, and :meth:`Connection.rollback` will implicitly open a new transaction (immediately after closing the pending one, for the latter two). :mod:`!sqlite3` uses ``BEGIN DEFERRED`` statements when opening transactions."
msgstr ":mod:`!sqlite3` تضمین می‌کند که یک تراکنش همیشه باز است، بنابراین :func:`connect`، :meth:`Connection.commit` و :meth:`Connection.rollback` به‌طور ضمنی یک تراکنش جدید باز می‌کنند (بلافاصله پس از بستن تراکنش در انتظار، برای دو مورد آخر). :mod:`!sqlite3` هنگام باز کردن تراکنش‌ها از دستورات ``BEGIN DEFERRED`` استفاده می‌کند."

msgid "Transactions should be committed explicitly using :meth:`!commit`."
msgstr "تراکنش‌ها باید به‌صورت صریح با استفاده از :meth:`!commit` کامیت شوند."

msgid "Transactions should be rolled back explicitly using :meth:`!rollback`."
msgstr "تراکنش‌ها باید به‌صراحت با استفاده از :meth:`!rollback` بازگردانی شوند."

msgid "An implicit rollback is performed if the database is :meth:`~Connection.close`-ed with pending changes."
msgstr "اگر پایگاه داده در حالی که تغییرات در انتظار دارد با :meth:`~Connection.close` بسته شود، یک بازگردانی (rollback) ضمنی انجام می‌شود."

msgid "Set *autocommit* to ``True`` to enable SQLite's `autocommit mode`_. In this mode, :meth:`Connection.commit` and :meth:`Connection.rollback` have no effect. Note that SQLite's autocommit mode is distinct from the :pep:`249`-compliant :attr:`Connection.autocommit` attribute; use :attr:`Connection.in_transaction` to query the low-level SQLite autocommit mode."
msgstr "برای فعال‌سازی `autocommit mode`_ در SQLite، *autocommit* را روی ``True`` تنظیم کنید. در این حالت، :meth:`Connection.commit` و :meth:`Connection.rollback` هیچ اثری ندارند. توجه داشته باشید که حالت autocommit در SQLite از ویژگی :attr:`Connection.autocommit` سازگار با :pep:`249` متمایز است؛ برای پرس‌وجوی حالت autocommit سطح پایین SQLite از :attr:`Connection.in_transaction` استفاده کنید."

msgid "Set *autocommit* to :data:`LEGACY_TRANSACTION_CONTROL` to leave transaction control behaviour to the :attr:`Connection.isolation_level` attribute. See :ref:`sqlite3-transaction-control-isolation-level` for more information."
msgstr "برای اینکه رفتار کنترل تراکنش به ویژگی :attr:`Connection.isolation_level` واگذار شود، *autocommit* را روی :data:`LEGACY_TRANSACTION_CONTROL` تنظیم کنید. برای اطلاعات بیشتر :ref:`sqlite3-transaction-control-isolation-level` را ببینید."

msgid "Transaction control via the ``isolation_level`` attribute"
msgstr "کنترل تراکنش از طریق ویژگی ``isolation_level``"

msgid "The recommended way of controlling transactions is via the :attr:`~Connection.autocommit` attribute. See :ref:`sqlite3-transaction-control-autocommit`."
msgstr "روش توصیه‌شده برای کنترل تراکنش‌ها، استفاده از ویژگی :attr:`~Connection.autocommit` است. :ref:`sqlite3-transaction-control-autocommit` را ببینید."

msgid "If :attr:`Connection.autocommit` is set to :data:`LEGACY_TRANSACTION_CONTROL` (the default), transaction behaviour is controlled using the :attr:`Connection.isolation_level` attribute. Otherwise, :attr:`!isolation_level` has no effect."
msgstr "اگر :attr:`Connection.autocommit` روی :data:`LEGACY_TRANSACTION_CONTROL` (پیش‌فرض) تنظیم شده باشد، رفتار تراکنش با استفاده از ویژگی :attr:`Connection.isolation_level` کنترل می‌شود. در غیر این صورت، :attr:`!isolation_level` اثری ندارد."

msgid "If the connection attribute :attr:`~Connection.isolation_level` is not ``None``, new transactions are implicitly opened before :meth:`~Cursor.execute` and :meth:`~Cursor.executemany` executes ``INSERT``, ``UPDATE``, ``DELETE``, or ``REPLACE`` statements; for other statements, no implicit transaction handling is performed. Use the :meth:`~Connection.commit` and :meth:`~Connection.rollback` methods to respectively commit and roll back pending transactions. You can choose the underlying `SQLite transaction behaviour`_ — that is, whether and what type of ``BEGIN`` statements :mod:`!sqlite3` implicitly executes – via the :attr:`~Connection.isolation_level` attribute."
msgstr "اگر ویژگی اتصال :attr:`~Connection.isolation_level` برابر ``None`` نباشد، پیش از اجرای دستورات ``INSERT``، ``UPDATE``، ``DELETE`` یا ``REPLACE`` توسط :meth:`~Cursor.execute` و :meth:`~Cursor.executemany`، تراکنش‌های جدید به‌طور ضمنی باز می‌شوند؛ برای سایر دستورات، هیچ مدیریت تراکنش ضمنی‌ای انجام نمی‌شود. از متدهای :meth:`~Connection.commit` و :meth:`~Connection.rollback` به‌ترتیب برای ثبت (commit) و بازگرداندن (rollback) تراکنش‌های در انتظار استفاده کنید. شما می‌توانید رفتار زیربنایی `SQLite transaction behaviour`_ — یعنی اینکه آیا و چه نوع دستورات ``BEGIN`` توسط :mod:`!sqlite3` به‌طور ضمنی اجرا می‌شوند – را از طریق ویژگی :attr:`~Connection.isolation_level` انتخاب کنید."

msgid "If :attr:`~Connection.isolation_level` is set to ``None``, no transactions are implicitly opened at all. This leaves the underlying SQLite library in `autocommit mode`_, but also allows the user to perform their own transaction handling using explicit SQL statements. The underlying SQLite library autocommit mode can be queried using the :attr:`~Connection.in_transaction` attribute."
msgstr "اگر :attr:`~Connection.isolation_level` روی ``None`` تنظیم شده باشد، اصلاً هیچ تراکنشی به‌طور ضمنی باز نمی‌شود. این امر باعث می‌شود کتابخانه SQLite زیرین در `autocommit mode`_ باقی بماند، اما همچنین به کاربر اجازه می‌دهد مدیریت تراکنش خود را با استفاده از دستورات صریح SQL انجام دهد. حالت کامیت خودکار کتابخانه SQLite زیرین را می‌توان از طریق ویژگی :attr:`~Connection.in_transaction` پرس‌وجو کرد."

msgid "The :meth:`~Cursor.executescript` method implicitly commits any pending transaction before execution of the given SQL script, regardless of the value of :attr:`~Connection.isolation_level`."
msgstr "متد :meth:`~Cursor.executescript` به‌طور ضمنی هر تراکنش در حال انتظاری را پیش از اجرای اسکریپت SQL داده‌شده، صرف‌نظر از مقدار :attr:`~Connection.isolation_level`، ثبت (commit) می‌کند."

msgid ":mod:`!sqlite3` used to implicitly commit an open transaction before DDL statements.  This is no longer the case."
msgstr ":mod:`!sqlite3` پیش‌تر یک تراکنش باز را پیش از دستورات DDL به‌صورت ضمنی ثبت (commit) می‌کرد. این موضوع دیگر صدق نمی‌کند."

msgid "The recommended way of controlling transactions is now via the :attr:`~Connection.autocommit` attribute."
msgstr "روش توصیه‌شده برای کنترل تراکنش‌ها اکنون از طریق ویژگی :attr:`~Connection.autocommit` است."

msgid "? (question mark)"
msgstr "? (علامت سؤال)"

msgid "in SQL statements"
msgstr "در دستورات SQL"

msgid ": (colon)"
msgstr ": (دونقطه)"

#~ msgid "Positional use of the parameters *timeout*, *detect_types*, *isolation_level*, *check_same_thread*, *factory*, *cached_statements*, and *uri* is deprecated. They will become keyword-only parameters in Python 3.15."
#~ msgstr "استفاده‌ی جایگاهی از پارامترهای *timeout*، *detect_types*، *isolation_level*، *check_same_thread*، *factory*، *cached_statements* و *uri* منسوخ شده است. این پارامترها در پایتون 3.15 به پارامترهای فقط کلیدواژه‌ای تبدیل خواهند شد."

#~ msgid "Passing *name*, *narg*, and *func* as keyword arguments is deprecated. These parameters will become positional-only in Python 3.15."
#~ msgstr "ارسال *name*، *narg* و *func* به‌صورت آرگومان‌های کلیدواژه‌ای منسوخ شده است. این پارامترها در پایتون 3.15 فقط جایگاهی خواهند شد."

#~ msgid "Passing *name*, *n_arg*, and *aggregate_class* as keyword arguments is deprecated. These parameters will become positional-only in Python 3.15."
#~ msgstr "ارسال *name*، *n_arg* و *aggregate_class* به‌صورت آرگومان‌های کلیدواژه‌ای منسوخ شده است. این پارامترها در پایتون 3.15 فقط جایگاهی خواهند شد."

#~ msgid "Passing *authorizer_callback* as a keyword argument is deprecated. The parameter will become positional-only in Python 3.15."
#~ msgstr "ارسال *authorizer_callback* به‌عنوان آرگومان کلیدواژه‌ای منسوخ شده است. این پارامتر در پایتون 3.15 فقط جایگاهی خواهد شد."

#~ msgid "Passing *progress_handler* as a keyword argument is deprecated. The parameter will become positional-only in Python 3.15."
#~ msgstr "ارسال *progress_handler* به‌عنوان آرگومان کلیدواژه‌ای منسوخ شده است. این پارامتر در Python 3.15 فقط جایگاهی خواهد شد."

#~ msgid "Passing *trace_callback* as a keyword argument is deprecated. The parameter will become positional-only in Python 3.15."
#~ msgstr "ارسال *trace_callback* به‌عنوان آرگومان کلیدواژه‌ای منسوخ شده است. این پارامتر در پایتون 3.15 فقط جایگاهی خواهد شد."