"sqlite3" --- SQLite 데이터베이스용 DB-API 2.0 인터페이스
*********************************************************

**소스 코드:** Lib/sqlite3/

======================================================================

SQLite는 별도의 서버 프로세스가 필요 없고 SQL 질의 언어의 비표준 변형
을 사용하여 데이터베이스에 액세스할 수 있는 경량 디스크 기반 데이터베
이스를 제공하는 C 라이브러리입니다. 일부 응용 프로그램은 내부 데이터
저장을 위해 SQLite를 사용할 수 있습니다. SQLite를 사용하여 응용 프로그
램을 프로토타입 한 다음 PostgreSQL 이나 Oracle과 같은 더 큰 데이터베이
스로 코드를 이식할 수도 있습니다.

The 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**.

To use the module, start by creating a "Connection" object that
represents the database.  Here the data will be stored in the
"example.db" file:

   import sqlite3
   con = sqlite3.connect('example.db')

The special path name ":memory:" can be provided to create a temporary
database in RAM.

Once a "Connection" has been established, create a "Cursor" object and
call its "execute()" method to perform SQL commands:

   cur = con.cursor()

   # Create table
   cur.execute('''CREATE TABLE stocks
                  (date text, trans text, symbol text, qty real, price real)''')

   # Insert a row of data
   cur.execute("INSERT INTO stocks VALUES ('2006-01-05','BUY','RHAT',100,35.14)")

   # Save (commit) the changes
   con.commit()

   # We can also close the connection if we are done with it.
   # Just be sure any changes have been committed or they will be lost.
   con.close()

The saved data is persistent: it can be reloaded in a subsequent
session even after restarting the Python interpreter:

   import sqlite3
   con = sqlite3.connect('example.db')
   cur = con.cursor()

To retrieve data after executing a SELECT statement, either treat the
cursor as an *iterator*, call the cursor's "fetchone()" method to
retrieve a single matching row, or call "fetchall()" to get a list of
the matching rows.

이 예제는 이터레이터 방식을 사용합니다:

   >>> for row in cur.execute('SELECT * FROM stocks ORDER BY price'):
           print(row)

   ('2006-01-05', 'BUY', 'RHAT', 100, 35.14)
   ('2006-03-28', 'BUY', 'IBM', 1000, 45.0)
   ('2006-04-06', 'SELL', 'IBM', 500, 53.0)
   ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)

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 (see the xkcd
webcomic for a humorous example of what can go wrong):

   # Never do this -- insecure!
   symbol = 'RHAT'
   cur.execute("SELECT * FROM stocks WHERE symbol = '%s'" % symbol)

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 "tuple" of
values to the second argument of the cursor's "execute()" method. 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 *sequence*. For the named style, it can
be either a *sequence* or "dict" instance. The length of the
*sequence* must match the number of placeholders, or a
"ProgrammingError" is raised. If a "dict" is given, it must contain
keys for all named parameters. Any extra items are ignored. Here's an
example of both styles:

   import sqlite3

   con = sqlite3.connect(":memory:")
   cur = con.cursor()
   cur.execute("create table lang (name, first_appeared)")

   # This is the qmark style:
   cur.execute("insert into lang values (?, ?)", ("C", 1972))

   # The qmark style used with executemany():
   lang_list = [
       ("Fortran", 1957),
       ("Python", 1991),
       ("Go", 2009),
   ]
   cur.executemany("insert into lang values (?, ?)", lang_list)

   # And this is the named style:
   cur.execute("select * from lang where first_appeared=:year", {"year": 1972})
   print(cur.fetchall())

   con.close()

더 보기:

  https://www.sqlite.org
     SQLite 웹 페이지; 설명서는 지원되는 SQL 언어에 대한 문법과 사용
     가능한 데이터형을 설명합니다.

  https://www.w3schools.com/sql/
     SQL 문법 학습을 위한 자습서, 레퍼런스 및 예제

  **PEP 249** - 데이터베이스 API 명세 2.0
     Marc-André Lemburg가 작성한 PEP.


모듈 함수와 상수
================

sqlite3.apilevel

   String constant stating the supported DB-API level. Required by the
   DB-API. Hard-coded to ""2.0"".

sqlite3.paramstyle

   String constant stating the type of parameter marker formatting
   expected by the "sqlite3" module. Required by the DB-API. Hard-
   coded to ""qmark"".

   참고:

     The "sqlite3" module supports both "qmark" and "numeric" DB-API
     parameter styles, because that is what the underlying SQLite
     library supports. However, the DB-API does not allow multiple
     values for the "paramstyle" attribute.

sqlite3.version

   이 모듈의 버전 번호(문자열). SQLite 라이브러리의 버전이 아닙니다.

sqlite3.version_info

   이 모듈의 버전 번호(정수들의 튜플). SQLite 라이브러리의 버전이 아닙
   니다.

sqlite3.sqlite_version

   런타임 SQLite 라이브러리의 버전 번호(문자열).

sqlite3.sqlite_version_info

   런타임 SQLite 라이브러리의 버전 번호(정수들의 튜플).

sqlite3.threadsafety

   Integer constant required by the DB-API, stating the level of
   thread safety the "sqlite3" module supports. Currently hard-coded
   to "1", meaning *"Threads may share the module, but not
   connections."* However, this may not always be true. You can check
   the underlying SQLite library's compile-time threaded mode using
   the following query:

      import sqlite3
      con = sqlite3.connect(":memory:")
      con.execute("""
          select * from pragma_compile_options
          where compile_options like 'THREADSAFE=%'
      """).fetchall()

   Note that the SQLITE_THREADSAFE levels do not match the DB-API 2.0
   "threadsafety" levels.

sqlite3.PARSE_DECLTYPES

   이 상수는 "connect()" 함수의 *detect_types* 매개 변수에 사용됩니다.

   이것을 설정하면 "sqlite3" 모듈은 반환되는 각 열에 대해 선언된 형을
   구문 분석합니다. 선언된 형의 첫 번째 단어를 구문 분석합니다, 즉
   "integer primary key"에서는 "integer"를, "number (10)"에서는
   "number"를 구문 분석합니다. 그런 다음 해당 열에 대해, 변환기 딕셔너
   리를 조사하고 그 형에 대해 등록된 변환기 함수를 사용합니다.

sqlite3.PARSE_COLNAMES

   이 상수는 "connect()" 함수의 *detect_types* 매개 변수에 사용됩니다.

   Setting this makes the SQLite interface parse the column name for
   each column it returns.  It will look for a string formed [mytype]
   in there, and then decide that 'mytype' is the type of the column.
   It will try to find an entry of 'mytype' in the converters
   dictionary and then use the converter function found there to
   return the value. The column name found in "Cursor.description"
   does not include the type, i. e. if you use something like "'as
   "Expiration date [datetime]"'" in your SQL, then we will parse out
   everything until the first "'['" for the column name and strip the
   preceding space: the column name would simply be "Expiration date".

sqlite3.connect(database[, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri])

   SQLite 데이터베이스 파일 *database*에 대한 연결을 엽니다. 사용자 정
   의 *factory*가 주어지지 않는 한, 기본적으로 "Connection" 객체를 반
   환합니다.

   *database*는 열릴 데이터베이스 파일의 경로명(절대 혹은 현재 작업 디
   렉터리에 대한 상대)을 제공하는 *경로류 객체*입니다. "":memory:""를
   사용하여 디스크 대신 램(RAM)에 있는 데이터베이스에 대한 데이터베이
   스 연결을 열 수 있습니다.

   데이터베이스가 여러 연결을 통해 액세스 되고, 프로세스 중 하나가 데
   이터베이스를 수정할 때, 해당 트랜잭션이 커밋될 때까지 SQLite 데이터
   베이스가 잠깁니다. *timeout* 매개 변수는 예외를 일으키기 전에 잠금
   이 해제되기를 연결이 기다려야 하는 시간을 지정합니다. timeout 매개
   변수의 기본값은 5.0(5초)입니다.

   *isolation_level* 매개 변수는 "Connection" 객체의 "isolation_level"
   프로퍼티를 참조하십시오.

   SQLite는 기본적으로 TEXT, INTEGER, REAL, BLOB 및 NULL 형만 지원합니
   다. 다른 형을 사용하려면 직접 지원을 추가해야 합니다.
   *detect_types* 매개 변수와 모듈 수준 "register_converter()" 함수로
   등록된 사용자 정의 **변환기**를 사용하면 쉽게 할 수 있습니다.

   *detect_types*의 기본값은 0입니다 (즉, 형 감지가 없습니다).
   "PARSE_DECLTYPES"와 "PARSE_COLNAMES"의 조합으로 설정하여 형 감지를
   켤 수 있습니다. SQLite 동작으로 인해, *detect_types* 매개 변수가 설
   정되어 있을 때조차, 생성된 필드(예를 들어 "max(data)")에 대해 형을
   감지할 수 없습니다. 이 경우, 반환되는 형은 "str" 입니다.

   기본적으로 *check_same_thread*는 "True"며, 만들고 있는 스레드 만 이
   연결을 사용할 수 있습니다. "False"로 설정하면 반환된 연결을 여러 스
   레드에서 공유할 수 있습니다. 여러 스레드에서 같은 연결을 사용할 때,
   데이터 손상을 피하려면 쓰기 연산을 사용자가 직렬화해야 합니다.

   기본적으로, "sqlite3" 모듈은 connect 호출에 "Connection" 클래스를
   사용합니다. 그러나, "Connection" 클래스의 서브 클래스를 만들고
   *factory* 매개 변수에 클래스를 제공하면 "connect()"가 그 클래스를
   사용하게 할 수 있습니다.

   자세한 내용은 이 설명서의 섹션 SQLite 와 파이썬 형을 참조하십시오.

   "sqlite3" 모듈은 내부적으로 SQL 구문 분석 오버헤드를 피하고자 명령
   문 캐시를 사용합니다. 연결에 대해 캐시 되는 명령문의 수를 명시적으
   로 설정하려면, *cached_statements* 매개 변수를 설정할 수 있습니다.
   현재 구현된 기본값은 100개의 명령문을 캐시 하는 것입니다.

   If *uri* is "True", *database* is interpreted as a URI (Uniform
   Resource Identifier) with a file path and an optional query string.
   The scheme part *must* be ""file:"".  The path can be a relative or
   absolute file path.  The query string allows us to pass parameters
   to SQLite. Some useful URI tricks include:

      # Open a database in read-only mode.
      con = sqlite3.connect("file:template.db?mode=ro", uri=True)

      # Don't implicitly create a new database file if it does not already exist.
      # Will raise sqlite3.OperationalError if unable to open a database file.
      con = sqlite3.connect("file:nosuchdb.db?mode=rw", uri=True)

      # Create a shared named in-memory database.
      con1 = sqlite3.connect("file:mem1?mode=memory&cache=shared", uri=True)
      con2 = sqlite3.connect("file:mem1?mode=memory&cache=shared", uri=True)
      con1.executescript("create table t(t); insert into t values(28);")
      rows = con2.execute("select * from t").fetchall()

   More information about this feature, including a list of recognized
   parameters, can be found in the SQLite URI documentation.

   인자 "database"로 감사 이벤트(auditing event) "sqlite3.connect"를
   발생시킵니다.

   버전 3.4에서 변경: *uri* 매개 변수가 추가되었습니다.

   버전 3.7에서 변경: *database*는 이제 문자열뿐만 아니라 *경로류 객체
   * 일 수도 있습니다.

sqlite3.register_converter(typename, callable)

   데이터베이스의 바이트열을 사용자 정의 파이썬 형으로 변환할 수 있는
   콜러블을 등록합니다. 콜러블은 형 *typename* 인 모든 데이터베이스 값
   에 대해 호출됩니다. 형 감지 작동 방식에 대해서는 "connect()" 함수의
   매개 변수 *detect_types*를 참고하십시오. *typename*과 질의의 형 이
   름은 대/소문자를 구분하지 않고 일치시킴에 유의하십시오.

sqlite3.register_adapter(type, callable)

   사용자 정의 파이썬 형 *type*을 SQLite의 지원되는 형 중 하나로 변환
   할 수 있는 콜러블을 등록합니다. 콜러블 *callable*은 단일 매개 변수
   로 파이썬 값을 받아들이고 다음 형들의 값을 반환해야 합니다: int,
   float, str 또는 bytes.

sqlite3.complete_statement(sql)

   문자열 *sql*에 세미콜론으로 끝나는 하나 이상의 완전한 SQL 문이 포함
   되어 있으면 "True"를 반환합니다. SQL이 문법적으로 올바른지 확인하지
   는 않습니다. 닫히지 않은 문자열 리터럴이 없고 명령문이 세미콜론으로
   끝나는지만 확인합니다.

   이것은 다음 예제와 같이, SQLite 용 셸을 만드는데 사용할 수 있습니다
   :

      # A minimal SQLite shell for experiments

      import sqlite3

      con = sqlite3.connect(":memory:")
      con.isolation_level = None
      cur = con.cursor()

      buffer = ""

      print("Enter your SQL commands to execute in sqlite3.")
      print("Enter a blank line to exit.")

      while True:
          line = input()
          if line == "":
              break
          buffer += line
          if sqlite3.complete_statement(buffer):
              try:
                  buffer = buffer.strip()
                  cur.execute(buffer)

                  if buffer.lstrip().upper().startswith("SELECT"):
                      print(cur.fetchall())
              except sqlite3.Error as e:
                  print("An error occurred:", e.args[0])
              buffer = ""

      con.close()

sqlite3.enable_callback_tracebacks(flag)

   기본적으로 사용자 정의 함수, 집계(aggregates), 변환기, 인가
   (authorizer) 콜백 등에서는 트레이스백을 얻지 못합니다. 디버깅하려면
   *flag*를 "True"로 설정하여 이 함수를 호출할 수 있습니다. 그러면,
   "sys.stderr"로 콜백의 트레이스백을 얻게 됩니다. 기능을 다시 비활성
   화하려면 "False"를 사용하십시오.


Connection 객체
===============

class sqlite3.Connection

   An SQLite database connection has the following attributes and
   methods:

   isolation_level

      현재의 기본 격리 수준을 가져오거나 설정합니다. 자동 커밋 모드를
      뜻하는 "None" 이나 "DEFERRED", "IMMEDIATE" 또는 "EXCLUSIVE" 중
      하나입니다. 자세한 설명은 트랜잭션 제어 절을 참조하십시오.

   in_transaction

      트랜잭션이 활성화 상태면(커밋되지 않은 변경 사항이 있으면)
      "True", 그렇지 않으면 "False". 읽기 전용 어트리뷰트.

      버전 3.2에 추가.

   cursor(factory=Cursor)

      cursor 메서드는 단일 선택적 매개 변수 *factory*를 받아들입니다.
      제공되면, 이것은 "Cursor" 나 그 서브 클래스의 인스턴스를 반환하
      는 콜러블이어야 합니다.

   commit()

      이 메서드는 현재 트랜잭션을 커밋합니다. 이 메서드를 호출하지 않
      으면, 마지막 "commit()" 호출 이후에 수행한 작업은 다른 데이터베
      이스 연결에서 볼 수 없습니다. 데이터베이스에 기록한 데이터가 왜
      보이지 않는지 궁금하면, 이 메서드를 호출하는 것을 잊지 않았는지
      확인하십시오.

   rollback()

      이 메서드는 마지막 "commit()" 호출 이후의 데이터베이스에 대한 모
      든 변경 사항을 되돌립니다.

   close()

      데이터베이스 연결을 닫습니다. 자동으로 "commit()"을 호출하지 않
      음에 유의하십시오. "commit()"를 먼저 호출하지 않고 데이터베이스
      연결을 닫으면 변경 사항이 손실됩니다!

   execute(sql[, parameters])

      Create a new "Cursor" object and call "execute()" on it with the
      given *sql* and *parameters*. Return the new cursor object.

   executemany(sql[, parameters])

      Create a new "Cursor" object and call "executemany()" on it with
      the given *sql* and *parameters*. Return the new cursor object.

   executescript(sql_script)

      Create a new "Cursor" object and call "executescript()" on it
      with the given *sql_script*. Return the new cursor object.

   create_function(name, num_params, func, *, deterministic=False)

      나중에 함수 이름 *name*으로 SQL 문에서 사용할 수 있는 사용자 정
      의 함수를 만듭니다. *num_params*는 함수가 받아들이는 매개 변수의
      수입니다 (*num_params*가 -1이면 함수는 임의의 인자를 취할 수 있
      습니다). *func*는 SQL 함수로 호출되는 파이썬 콜러블입니다.
      *deterministic*이 참이면, 만들어진 함수는 SQLite가 추가적인 최적
      화를 수행할 수 있도록 결정론적(deterministic)으로 표시됩니다. 이
      플래그는 SQLite 3.8.3 이상에서 지원됩니다, 이전 버전에서 사용되
      면 "NotSupportedError"가 발생합니다.

      함수는 SQLite가 지원하는 모든 형을 반환할 수 있습니다: bytes,
      str, int, float 및 "None".

      버전 3.8에서 변경: *deterministic* 매개 변수가 추가되었습니다.

      예:

         import sqlite3
         import hashlib

         def md5sum(t):
             return hashlib.md5(t).hexdigest()

         con = sqlite3.connect(":memory:")
         con.create_function("md5", 1, md5sum)
         cur = con.cursor()
         cur.execute("select md5(?)", (b"foo",))
         print(cur.fetchone()[0])

         con.close()

   create_aggregate(name, num_params, aggregate_class)

      사용자 정의 집계(aggregate) 함수를 만듭니다.

      매개 변수의 수 *num_params*(*num_params*가 -1이면 함수는 임의의
      인자를 취할 수 있습니다)를 받아들이며, 집계 클래스는 "step" 메서
      드와 집계의 최종 결과를 반환하는 "finalize" 메서드를 구현해야 합
      니다.

      "finalize" 메서드는 SQLite가 지원하는 모든 형을 반환할 수 있습니
      다: bytes, str, int, float 및 "None".

      예:

         import sqlite3

         class MySum:
             def __init__(self):
                 self.count = 0

             def step(self, value):
                 self.count += value

             def finalize(self):
                 return self.count

         con = sqlite3.connect(":memory:")
         con.create_aggregate("mysum", 1, MySum)
         cur = con.cursor()
         cur.execute("create table test(i)")
         cur.execute("insert into test(i) values (1)")
         cur.execute("insert into test(i) values (2)")
         cur.execute("select mysum(i) from test")
         print(cur.fetchone()[0])

         con.close()

   create_collation(name, callable)

      지정된 *name* 과 *callable*로 정렬법(collation)을 만듭니다. 콜러
      블에는 두 개의 문자열 인자가 전달됩니다. 첫째가 둘째보다 작은 순
      서면 -1, 같은 순서면 0, 첫째가 둘째보다 큰 순서면 1을 반환 해야
      합니다. 이것은 정렬(SQL의 ORDER BY)을 제어하므로, 여러분의 비교
      는 다른 SQL 연산에 영향을 주지 않습니다.

      콜러블 객체는 보통 UTF-8로 인코딩된 파이썬 바이트열로 매개 변수
      를 가져옵니다.

      다음 예제는 "잘못된 방법"으로 정렬하는 사용자 정의 정렬법을 보여
      줍니다:

         import sqlite3

         def collate_reverse(string1, string2):
             if string1 == string2:
                 return 0
             elif string1 < string2:
                 return 1
             else:
                 return -1

         con = sqlite3.connect(":memory:")
         con.create_collation("reverse", collate_reverse)

         cur = con.cursor()
         cur.execute("create table test(x)")
         cur.executemany("insert into test(x) values (?)", [("a",), ("b",)])
         cur.execute("select x from test order by x collate reverse")
         for row in cur:
             print(row)
         con.close()

      정렬법을 제거하려면 callable에 "None"을 사용해서
      "create_collation"를 호출하십시오:

         con.create_collation("reverse", None)

   interrupt()

      연결에서 실행 중일 수 있는 모든 질의를 중단하려면, 이 메서드를
      다른 스레드에서 호출할 수 있습니다. 그러면 질의가 중단되고 호출
      자는 예외를 받습니다.

   set_authorizer(authorizer_callback)

      이 루틴은 콜백을 등록합니다. 콜백은 데이터베이스의 테이블 열에
      액세스할 때마다 호출됩니다. 콜백은 액세스가 허용되면 "SQLITE_OK"
      를 반환하고, 전체 SQL 문을 에러를 일으키며 중단해야 하면
      "SQLITE_DENY"를, 열을 NULL 값으로 처리하려면 "SQLITE_IGNORE"를
      반환해야 합니다. 이 상수들은 "sqlite3" 모듈에 있습니다.

      콜백의 첫 번째 인자는 어떤 종류의 연산이 인가받으려 하는지를 나
      타냅니다. 두 번째와 세 번째 인자는 첫 번째 인자에 따라 인자이거
      나 "None"이 됩니다. 네 번째 인자는 해당하면 데이터베이스 이름
      ("main", "temp" 등)입니다. 다섯 번째 인자는 액세스 시도를 담당하
      는 가장 안쪽의 트리거나 뷰의 이름이거나, 이 액세스 시도가 입력
      SQL 코드에서 직접 발생했으면 "None"입니다.

      첫 번째 인자에 가능한 값과 첫 번째 인자에 의존하는 두 번째 및 세
      번째 인자의 의미에 대해서는 SQLite 문서를 참조하십시오. 필요한
      모든 상수는 "sqlite3" 모듈에 있습니다.

   set_progress_handler(handler, n)

      이 루틴은 콜백을 등록합니다. 콜백은 SQLite 가상 머신의 매 *n*개
      의 명령어마다 호출됩니다. 장시간 실행되는 작업 중에 SQLite로부터
      호출되기를 원할 때 유용합니다, 예를 들어 GUI를 갱신하는데 사용할
      수 있습니다.

      이전에 설치된 모든 진행 처리기를 지우려면 *handler*로 "None"을
      사용하여 메서드를 호출하십시오.

      처리기 함수에서 0이 아닌 값을 반환하면 현재 실행 중인 질의가 종
      료되고 "OperationalError" 예외가 발생합니다.

   set_trace_callback(trace_callback)

      SQLite 백 엔드가 실제로 실행하는 각 SQL 문마다 호출할
      *trace_callback*을 등록합니다.

      The only argument passed to the callback is the statement (as
      "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 "Cursor.execute()" methods.  Other sources include
      the transaction management of the sqlite3 module and the
      execution of triggers defined in the current database.

      "None"을 *trace_callback*로 전달하면 추적 콜백을 비활성화합니다.

      참고:

        Exceptions raised in the trace callback are not propagated. As
        a development and debugging aid, use
        "enable_callback_tracebacks()" to enable printing tracebacks
        from exceptions raised in the trace callback.

      버전 3.3에 추가.

   enable_load_extension(enabled)

      이 루틴은 SQLite 엔진이 공유 라이브러리에서 SQLite 확장을 로드하
      는 것을 허용/불허합니다. SQLite 확장은 새 함수, 집계 또는 완전히
      새로운 가상 테이블 구현을 정의할 수 있습니다. 잘 알려진 확장 중
      하나는 SQLite와 함께 배포되는 전체 텍스트 검색 확장입니다.

      로드 가능한 확장은 기본적으로 비활성화되어 있습니다. [1]를 보세
      요.

      버전 3.2에 추가.

         import sqlite3

         con = sqlite3.connect(":memory:")

         # enable extension loading
         con.enable_load_extension(True)

         # Load the fulltext search extension
         con.execute("select load_extension('./fts3.so')")

         # alternatively you can load the extension using an API call:
         # con.load_extension("./fts3.so")

         # disable extension loading again
         con.enable_load_extension(False)

         # example from SQLite wiki
         con.execute("create virtual table recipe using fts3(name, ingredients)")
         con.executescript("""
             insert into recipe (name, ingredients) values ('broccoli stew', 'broccoli peppers cheese tomatoes');
             insert into recipe (name, ingredients) values ('pumpkin stew', 'pumpkin onions garlic celery');
             insert into recipe (name, ingredients) values ('broccoli pie', 'broccoli cheese onions flour');
             insert into recipe (name, ingredients) values ('pumpkin pie', 'pumpkin sugar flour butter');
             """)
         for row in con.execute("select rowid, name, ingredients from recipe where name match 'pie'"):
             print(row)

         con.close()

   load_extension(path)

      This routine loads an SQLite extension from a shared library.
      You have to enable extension loading with
      "enable_load_extension()" before you can use this routine.

      로드 가능한 확장은 기본적으로 비활성화되어 있습니다. [1]를 보세
      요.

      버전 3.2에 추가.

   row_factory

      이 어트리뷰트를 커서와 원본 행을 튜플로 받아들이고 실제 결과 행
      을 반환하는 콜러블로 변경할 수 있습니다. 이렇게 하면, 이름으로
      열을 액세스할 수 있는 객체를 반환하는 것과 같이, 결과를 반환하는
      더 고급 방식을 구현할 수 있습니다.

      예:

         import sqlite3

         def dict_factory(cursor, row):
             d = {}
             for idx, col in enumerate(cursor.description):
                 d[col[0]] = row[idx]
             return d

         con = sqlite3.connect(":memory:")
         con.row_factory = dict_factory
         cur = con.cursor()
         cur.execute("select 1 as a")
         print(cur.fetchone()["a"])

         con.close()

      튜플을 반환하는 것으로 충분하지 않고 열에 대한 이름 기반 액세스
      를 원하면, "row_factory"를 고도로 최적화된 "sqlite3.Row" 형으로
      설정하는 것을 고려해야 합니다. "Row"는 메모리 오버헤드가 거의 없
      이 열에 대해 인덱스 기반과 대소 문자를 구분하지 않는 이름 기반
      액세스를 제공합니다. 아마도 여러분 자신의 사용자 정의 딕셔너리
      기반 접근법이나 심지어 db_row 기반 해법보다 더 좋을 것입니다.

   text_factory

      Using this attribute you can control what objects are returned
      for the "TEXT" data type. By default, this attribute is set to
      "str" and the "sqlite3" module will return "str" objects for
      "TEXT". If you want to return "bytes" instead, you can set it to
      "bytes".

      하나의 바이트열 매개 변수를 받아들이고 결과 객체를 반환하는 다른
      콜러블 객체로 설정할 수도 있습니다.

      예시를 위해 다음 예제 코드를 참조하십시오:

         import sqlite3

         con = sqlite3.connect(":memory:")
         cur = con.cursor()

         AUSTRIA = "Österreich"

         # by default, rows are returned as str
         cur.execute("select ?", (AUSTRIA,))
         row = cur.fetchone()
         assert row[0] == AUSTRIA

         # but we can make sqlite3 always return bytestrings ...
         con.text_factory = bytes
         cur.execute("select ?", (AUSTRIA,))
         row = cur.fetchone()
         assert type(row[0]) is bytes
         # the bytestrings will be encoded in UTF-8, unless you stored garbage in the
         # database ...
         assert row[0] == AUSTRIA.encode("utf-8")

         # we can also implement a custom text_factory ...
         # here we implement one that appends "foo" to all strings
         con.text_factory = lambda x: x.decode("utf-8") + "foo"
         cur.execute("select ?", ("bar",))
         row = cur.fetchone()
         assert row[0] == "barfoo"

         con.close()

   total_changes

      데이터베이스 연결이 열린 후 수정, 삽입 또는 삭제된 데이터베이스
      행의 총수를 반환합니다.

   iterdump()

      SQL 텍스트 형식으로 데이터베이스를 덤프하는 이터레이터를 반환합
      니다. 나중에 복원할 수 있도록 메모리 데이터베이스를 저장할 때 유
      용합니다. 이 함수는 **sqlite3** 셸의 ".dump" 명령과 같은 기능을
      제공합니다.

      예:

         # Convert file existing_db.db to SQL dump file dump.sql
         import sqlite3

         con = sqlite3.connect('existing_db.db')
         with open('dump.sql', 'w') as f:
             for line in con.iterdump():
                 f.write('%s\n' % line)
         con.close()

   backup(target, *, pages=-1, progress=None, name="main", sleep=0.250)

      This method makes a backup of an SQLite database even while it's
      being accessed by other clients, or concurrently by the same
      connection.  The copy will be written into the mandatory
      argument *target*, that must be another "Connection" instance.

      기본적으로, 또는 *pages*가 "0" 이나 음의 정수이면, 전체 데이터베
      이스가 단일 단계로 복사됩니다; 그렇지 않으면 이 메서드는 한 번에
      최대 *pages* 페이지만큼 복사하는 루프를 수행합니다.

      *progress*가 지정되면, "None" 또는 매 이터레이션마다 세 개의 정
      수 인자로 실행되는 콜러블 객체여야 합니다. 세 인자는 각각 직전
      이터레이션의 *상태(status)*, 아직 복사해야 할 *남은(remaining)*
      페이지 수, *전체(total)* 페이지 수입니다.

      *name* 인자는 복사할 데이터베이스 이름을 지정합니다: main 데이터
      베이스를 나타내는 ""main"", 기본값, 임시 데이터베이스를 나타내는
      ""temp"" 또는 첨부된 데이터베이스를 위한 "ATTACH DATABASE" 문에
      서 "AS" 키워드 뒤에 지정된 이름을 포함하는 문자열이어야 합니다.

      *sleep* 인자는 남은 페이지를 백업하는 연속적인 시도 사이에서 잠
      잘 시간을 초 단위로 지정하며, 정수 또는 부동 소수점 값으로 지정
      할 수 있습니다.

      예제 1, 기존 데이터베이스를 다른 데이터베이스로 복사:

         import sqlite3

         def progress(status, remaining, total):
             print(f'Copied {total-remaining} of {total} pages...')

         con = sqlite3.connect('existing_db.db')
         bck = sqlite3.connect('backup.db')
         with bck:
             con.backup(bck, pages=1, progress=progress)
         bck.close()
         con.close()

      예제 2, 기존 데이터베이스를 임시 복사본으로 복사:

         import sqlite3

         source = sqlite3.connect('existing_db.db')
         dest = sqlite3.connect(':memory:')
         source.backup(dest)

      가용성: SQLite 3.6.11 이상

      버전 3.7에 추가.


Cursor 객체
===========

class sqlite3.Cursor

   "Cursor" 인스턴스에는 다음과 같은 어트리뷰트와 메서드가 있습니다.

   execute(sql[, parameters])

      Executes an SQL statement. Values may be bound to the statement
      using placeholders.

      "execute()"는 단일 SQL 문만 실행합니다. 하나 이상의 명령문을 실
      행하려고 하면 "Warning"이 발생합니다. 하나의 호출로 여러 SQL 문
      을 실행하려면 "executescript()"를 사용하십시오.

   executemany(sql, seq_of_parameters)

      Executes a parameterized SQL command against all parameter
      sequences or mappings found in the sequence *seq_of_parameters*.
      The "sqlite3" module also allows using an *iterator* yielding
      parameters instead of a sequence.

         import sqlite3

         class IterChars:
             def __init__(self):
                 self.count = ord('a')

             def __iter__(self):
                 return self

             def __next__(self):
                 if self.count > ord('z'):
                     raise StopIteration
                 self.count += 1
                 return (chr(self.count - 1),) # this is a 1-tuple

         con = sqlite3.connect(":memory:")
         cur = con.cursor()
         cur.execute("create table characters(c)")

         theIter = IterChars()
         cur.executemany("insert into characters(c) values (?)", theIter)

         cur.execute("select c from characters")
         print(cur.fetchall())

         con.close()

      다음은 *제너레이터*를 사용하는 간단한 예입니다:

         import sqlite3
         import string

         def char_generator():
             for c in string.ascii_lowercase:
                 yield (c,)

         con = sqlite3.connect(":memory:")
         cur = con.cursor()
         cur.execute("create table characters(c)")

         cur.executemany("insert into characters(c) values (?)", char_generator())

         cur.execute("select c from characters")
         print(cur.fetchall())

         con.close()

   executescript(sql_script)

      This is a nonstandard convenience method for executing multiple
      SQL statements at once. It issues a "COMMIT" statement first,
      then executes the SQL script it gets as a parameter.  This
      method disregards "isolation_level"; any transaction control
      must be added to *sql_script*.

      *sql_script*는 "str"의 인스턴스가 될 수 있습니다.

      예:

         import sqlite3

         con = sqlite3.connect(":memory:")
         cur = con.cursor()
         cur.executescript("""
             create table person(
                 firstname,
                 lastname,
                 age
             );

             create table book(
                 title,
                 author,
                 published
             );

             insert into book(title, author, published)
             values (
                 'Dirk Gently''s Holistic Detective Agency',
                 'Douglas Adams',
                 1987
             );
             """)
         con.close()

   fetchone()

      질의 결과 집합의 다음 행을 가져옵니다. 단일 시퀀스를 반환하거나,
      데이터가 더 없을 때 "None"을 반환합니다.

   fetchmany(size=cursor.arraysize)

      질의 결과의 다음 행 집합을 가져와서, 리스트를 반환합니다. 행이
      더 없으면 빈 목록이 반환됩니다.

      호출 당 가져오는 행의 수는 *size* 매개 변수로 지정됩니다. 지정되
      어 않으면, 커서의 arraysize가 가져올 행의 수를 결정합니다. 이 메
      서드는 size 매개 변수가 나타내는 수만큼의 행을 가져오려고 해야
      합니다. 지정된 수의 행이 없어서 이것이 가능하지 않다면, 더 적은
      행이 반환될 수 있습니다.

      *size* 매개 변수와 관련된 성능 고려 사항이 있습니다. 최적의 성능
      을 위해서, 일반적으로 arraysize 어트리뷰트를 사용하는 것이 가장
      좋습니다. *size* 매개 변수가 사용되면, "fetchmany()" 호출마다 같
      은 값을 유지하는 것이 가장 좋습니다.

   fetchall()

      질의 결과의 모든 (남은) 행을 가져와서 리스트를 반환합니다. 커서
      의 arraysize 어트리뷰트는 이 연산의 성능에 영향을 줄 수 있습니다
      . 행이 없으면 빈 리스트가 반환됩니다.

   close()

      ("__del__"이 호출 될 때가 아니라) 지금 커서를 닫습니다.

      이 시점부터는 커서를 사용할 수 없습니다; 커서로 어떤 연산이건 시
      도하면 "ProgrammingError" 예외가 발생합니다.

   setinputsizes(sizes)

      Required by the DB-API. Does nothing in "sqlite3".

   setoutputsize(size[, column])

      Required by the DB-API. Does nothing in "sqlite3".

   rowcount

      "sqlite3" 모듈의 "Cursor" 클래스가 이 어트리뷰트를 구현하지만, "
      영향을 받는 행"/"선택된 행"의 판단을 위한 데이터베이스 엔진 자체
      지원은 기이합니다.

      "executemany()" 문에서, 수정 횟수는 "rowcount"에 합산됩니다.

      파이썬 DB API 스펙에 따라, "rowcount" 어트리뷰트는 커서에서
      "executeXX()"가 수행되지 않았거나 마지막 연산의 행 개수가 인터페
      이스에 의해 결정되지 않는 경우 -1입니다. 이런 경우는 "SELECT" 문
      을 포함하는데, 모든 행을 가져올 때까지 질의가 생성 한 행 수를 결
      정할 수 없기 때문입니다.

      3.6.5 이전의 SQLite 버전에서는, 조건 없이 "DELETE FROM table"을
      하면 "rowcount"가 0으로 설정됩니다.

   lastrowid

      This read-only attribute provides the row id of the last
      inserted row. It is only updated after successful "INSERT" or
      "REPLACE" statements using the "execute()" method.  For other
      statements, after "executemany()" or "executescript()", or if
      the insertion failed, the value of "lastrowid" is left
      unchanged.  The initial value of "lastrowid" is "None".

      참고:

        Inserts into "WITHOUT ROWID" tables are not recorded.

      버전 3.6에서 변경: "REPLACE" 문에 대한 지원이 추가되었습니다.

   arraysize

      "fetchmany()"에 의해 반환되는 행의 수를 제어하는 읽기/쓰기 어트
      리뷰트. 기본값은 1입니다. 이는 호출 당 하나의 행을 가져오는 것을
      뜻합니다.

   description

      이 읽기 전용 어트리뷰트는 마지막 질의의 열 이름을 제공합니다. 파
      이썬 DB API와의 호환성을 유지하기 위해, 각 열마다 7-튜플을 반환
      하는데, 각 튜플의 마지막 6개 항목은 "None" 입니다.

      일치하는 행이 없는 "SELECT" 문에도 설정됩니다.

   connection

      이 읽기 전용 어트리뷰트는 "Cursor" 객체가 사용하는 SQLite 데이터
      베이스 "Connection"을 제공합니다. "con.cursor()"를 호출하여 생성
      된 "Cursor" 객체는 *con*을 참조하는 "connection" 어트리뷰트를 가
      집니다:

         >>> con = sqlite3.connect(":memory:")
         >>> cur = con.cursor()
         >>> cur.connection == con
         True


Row 객체
========

class sqlite3.Row

   "Row" 인스턴스는 "Connection" 객체에 대해 고도로 최적화된
   "row_factory" 역할을 합니다. 대부분 기능에서 튜플을 모방하려고 합니
   다.

   열 이름과 인덱스에 의한 매핑 액세스와, 이터레이션, 표현(repr), 동등
   성 검사 및 "len()"을 지원합니다.

   두 개의 "Row" 객체가 정확히 같은 열을 갖고 그 구성원이 같으면 같다
   고 비교됩니다.

   keys()

      이 메서드는 열 이름 리스트를 반환합니다. 질의 직후,
      "Cursor.description"에 있는 각 튜플의 첫 번째 멤버입니다.

   버전 3.5에서 변경: 슬라이싱 지원이 추가되었습니다.

위에서 주어진 예제에서처럼 테이블을 초기화한다고 가정해 봅시다:

   con = sqlite3.connect(":memory:")
   cur = con.cursor()
   cur.execute('''create table stocks
   (date text, trans text, symbol text,
    qty real, price real)''')
   cur.execute("""insert into stocks
               values ('2006-01-05','BUY','RHAT',100,35.14)""")
   con.commit()
   cur.close()

이제 우리는 "Row"를 연결합니다:

   >>> con.row_factory = sqlite3.Row
   >>> cur = con.cursor()
   >>> cur.execute('select * from stocks')
   <sqlite3.Cursor object at 0x7f4e7dd8fa80>
   >>> r = cur.fetchone()
   >>> type(r)
   <class 'sqlite3.Row'>
   >>> tuple(r)
   ('2006-01-05', 'BUY', 'RHAT', 100.0, 35.14)
   >>> len(r)
   5
   >>> r[2]
   'RHAT'
   >>> r.keys()
   ['date', 'trans', 'symbol', 'qty', 'price']
   >>> r['qty']
   100.0
   >>> for member in r:
   ...     print(member)
   ...
   2006-01-05
   BUY
   RHAT
   100.0
   35.14


예외
====

exception sqlite3.Warning

   "Exception"의 서브 클래스.

exception sqlite3.Error

   이 모듈에 있는 다른 예외의 베이스 클래스. "Exception"의 서브 클래스
   입니다.

exception sqlite3.DatabaseError

   데이터베이스와 관련된 에러에 대해 발생하는 예외.

exception sqlite3.IntegrityError

   데이터베이스의 관계형 무결성이 영향을 받을 때 발생하는 예외. 예를
   들어, 외부 키(foreign key) 검사가 실패할 때. "DatabaseError"의 서브
   클래스입니다.

exception sqlite3.ProgrammingError

   프로그래밍 에러에 대한 예외, 예를 들어, 테이블을 찾을 수 없거나 이
   미 존재 함, SQL 문의 문법 에러, 지정된 매개 변수 개수가 잘못됨 등.
   "DatabaseError"의 서브 클래스입니다.

exception sqlite3.OperationalError

   데이터베이스 연산과 관련되고 프로그래머의 제어하에 있지 않은 에러에
   관한 오류. 예를 들어, 예기치 않은 단절이 발생하거나, 데이터 소스 이
   름을 찾을 수 없거나, 트랜잭션이 진행될 수 없을 때 등.
   "DatabaseError"의 서브 클래스입니다.

exception sqlite3.NotSupportedError

   데이터베이스에서 지원하지 않는 메서드나 데이터베이스 API가 사용될
   때 발생하는 예외. 예를 들어, 트랜잭션을 지원하지 않는 연결에서
   "rollback()" 메서드를 호출할 때. "DatabaseError"의 서브 클래스입니
   다.


SQLite 와 파이썬 형
===================


소개
----

SQLite는 기본적으로 다음 형을 지원합니다: "NULL", "INTEGER", "REAL",
"TEXT", "BLOB".

따라서 다음과 같은 파이썬 형을 아무 문제 없이 SQLite로 보낼 수 있습니
다:

+---------------------------------+---------------+
| 파이썬 형                       | SQLite 형     |
|=================================|===============|
| "None"                          | "NULL"        |
+---------------------------------+---------------+
| "int"                           | "INTEGER"     |
+---------------------------------+---------------+
| "float"                         | "REAL"        |
+---------------------------------+---------------+
| "str"                           | "TEXT"        |
+---------------------------------+---------------+
| "bytes"                         | "BLOB"        |
+---------------------------------+---------------+

이것은 SQLite 형이 기본적으로 파이썬 형으로 변환되는 방법입니다:

+---------------+------------------------------------------------+
| SQLite 형     | 파이썬 형                                      |
|===============|================================================|
| "NULL"        | "None"                                         |
+---------------+------------------------------------------------+
| "INTEGER"     | "int"                                          |
+---------------+------------------------------------------------+
| "REAL"        | "float"                                        |
+---------------+------------------------------------------------+
| "TEXT"        | "text_factory"에 따라 다릅니다, 기본적으로     |
|               | "str".                                         |
+---------------+------------------------------------------------+
| "BLOB"        | "bytes"                                        |
+---------------+------------------------------------------------+

The type system of the "sqlite3" module is extensible in two ways: you
can store additional Python types in an SQLite database via object
adaptation, and you can let the "sqlite3" module convert SQLite types
to different Python types via converters.


어댑터를 사용하여 SQLite 데이터베이스에 추가 파이썬 형을 저장하기
-----------------------------------------------------------------

앞에서 설명한 것처럼, SQLite는 기본적으로 제한된 형 집합만 지원합니다.
SQLite에 다른 파이썬 형을 사용하려면, SQLite에 대해 sqlite3 모듈이 지
원하는 형 중 하나로 **어댑트** 해야 합니다: NoneType, int, float, str,
bytes 중 하나.

"sqlite3" 모듈이 사용자 정의 파이썬 형을, 지원되는 형 중 하나로 어댑트
하도록 만드는 두 가지 방법이 있습니다.


객체가 스스로 어댑트하도록 하기
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

여러분이 스스로 클래스를 작성한다면 이것이 좋은 접근법입니다. 다음과
같은 클래스가 있다고 가정해 봅시다:

   class Point:
       def __init__(self, x, y):
           self.x, self.y = x, y

이제 Point를 단일 SQLite 열에 저장하려고 합니다. 먼저 포인트를 나타내
는데 사용할 지원되는 형 중 하나를 선택해야 합니다. str을 사용하고 좌표
를 세미콜론으로 분리하기로 합시다. 그런 다음 여러분의 클래스에 변환된
값을 반환하는 "__conform__(self, protocol)" 메서드를 제공해야 합니다.
매개 변수 *protocol*은 "PrepareProtocol"이 됩니다.

   import sqlite3

   class Point:
       def __init__(self, x, y):
           self.x, self.y = x, y

       def __conform__(self, protocol):
           if protocol is sqlite3.PrepareProtocol:
               return "%f;%f" % (self.x, self.y)

   con = sqlite3.connect(":memory:")
   cur = con.cursor()

   p = Point(4.0, -3.2)
   cur.execute("select ?", (p,))
   print(cur.fetchone()[0])

   con.close()


어댑터 콜러블 등록하기
~~~~~~~~~~~~~~~~~~~~~~

또 다른 가능성은 형을 문자열 표현으로 변환하는 함수를 만들고. 그 함수
를 "register_adapter()"로 등록하는 것입니다.

   import sqlite3

   class Point:
       def __init__(self, x, y):
           self.x, self.y = x, y

   def adapt_point(point):
       return "%f;%f" % (point.x, point.y)

   sqlite3.register_adapter(Point, adapt_point)

   con = sqlite3.connect(":memory:")
   cur = con.cursor()

   p = Point(4.0, -3.2)
   cur.execute("select ?", (p,))
   print(cur.fetchone()[0])

   con.close()

"sqlite3" 모듈에는 파이썬의 내장 "datetime.date" 와
"datetime.datetime" 형에 대한 두 개의 기본 어댑터가 있습니다. 이제
"datetime.datetime" 객체를 ISO 표현이 아닌 유닉스 타임스탬프로 저장하
려고 한다고 가정해 봅시다.

   import sqlite3
   import datetime
   import time

   def adapt_datetime(ts):
       return time.mktime(ts.timetuple())

   sqlite3.register_adapter(datetime.datetime, adapt_datetime)

   con = sqlite3.connect(":memory:")
   cur = con.cursor()

   now = datetime.datetime.now()
   cur.execute("select ?", (now,))
   print(cur.fetchone()[0])

   con.close()


SQLite 값을 사용자 정의 파이썬 형으로 변환하기
----------------------------------------------

어댑터를 작성하면 사용자 정의 파이썬 형을 SQLite로 보낼 수 있습니다.
그러나 실제로 유용하게 사용하려면 파이썬에서 SQLite를 거쳐 다시 파이썬
으로 돌아오는 순환이 동작하게 할 필요가 있습니다.

변환기를 사용하십시오.

"Point" 클래스로 돌아갑시다. 세미콜론으로 분리된 x와 y 좌표를 SQLite에
문자열로 저장했습니다.

먼저, 문자열을 매개 변수로 받아들이고 이것으로부터 "Point" 객체를 만드
는 변환기 함수를 정의합니다.

참고:

  변환기 함수는 **항상** SQLite로 보낸 값의 데이터형에 상관없이
  "bytes" 객체로 호출됩니다.

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

이제 "sqlite3" 모듈이 데이터베이스에서 select 한 것이 실제로 Point임을
알게 해야 합니다. 이렇게 하는 두 가지 방법이 있습니다:

* 선언된 형을 통해 묵시적으로

* 열 이름을 통해 명시적으로

두 가지 방법은 섹션 모듈 함수와 상수 의 상수 "PARSE_DECLTYPES" 와
"PARSE_COLNAMES"에 대한 항목에서 설명합니다.

다음 예는 두 가지 접근법을 보여줍니다.

   import sqlite3

   class Point:
       def __init__(self, x, y):
           self.x, self.y = x, y

       def __repr__(self):
           return "(%f;%f)" % (self.x, self.y)

   def adapt_point(point):
       return ("%f;%f" % (point.x, point.y)).encode('ascii')

   def convert_point(s):
       x, y = list(map(float, s.split(b";")))
       return Point(x, y)

   # Register the adapter
   sqlite3.register_adapter(Point, adapt_point)

   # Register the converter
   sqlite3.register_converter("point", convert_point)

   p = Point(4.0, -3.2)

   #########################
   # 1) Using declared types
   con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
   cur = con.cursor()
   cur.execute("create table test(p point)")

   cur.execute("insert into test(p) values (?)", (p,))
   cur.execute("select p from test")
   print("with declared types:", cur.fetchone()[0])
   cur.close()
   con.close()

   #######################
   # 1) Using column names
   con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES)
   cur = con.cursor()
   cur.execute("create table test(p)")

   cur.execute("insert into test(p) values (?)", (p,))
   cur.execute('select p as "p [point]" from test')
   print("with column names:", cur.fetchone()[0])
   cur.close()
   con.close()


기본 어댑터와 변환기
--------------------

datetime 모듈의 date와 datetime 형에 대한 기본 어댑터가 있습니다. 이것
들은 ISO 날짜/ISO 타임스탬프로 SQLite로 보내집니다.

기본 변환기는 "datetime.date"는 "date"라는 이름으로,
"datetime.datetime"은 "timestamp"라는 이름으로 등록됩니다.

이런 방법으로, 대부분 추가 작업 없이 파이썬의 날짜/타임스탬프를 사용할
수 있습니다. 어댑터의 형식은 실험적인 SQLite 날짜/시간 함수와도 호환됩
니다.

다음 예제는 이를 보여줍니다.

   import sqlite3
   import datetime

   con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
   cur = con.cursor()
   cur.execute("create table test(d date, ts timestamp)")

   today = datetime.date.today()
   now = datetime.datetime.now()

   cur.execute("insert into test(d, ts) values (?, ?)", (today, now))
   cur.execute("select d, ts from test")
   row = cur.fetchone()
   print(today, "=>", row[0], type(row[0]))
   print(now, "=>", row[1], type(row[1]))

   cur.execute('select current_date as "d [date]", current_timestamp as "ts [timestamp]"')
   row = cur.fetchone()
   print("current_date", row[0], type(row[0]))
   print("current_timestamp", row[1], type(row[1]))

   con.close()

SQLite에 저장된 타임스탬프가 6자리보다 긴 소수부가 있으면, 그 값은 타
임스탬프 변환기에 의해 마이크로초 정밀도로 잘립니다.

참고:

  The default "timestamp" converter ignores UTC offsets in the
  database and always returns a naive "datetime.datetime" object. To
  preserve UTC offsets in timestamps, either leave converters
  disabled, or register an offset-aware converter with
  "register_converter()".


트랜잭션 제어
=============

하부 "sqlite3" 라이브러리는 기본적으로 "autocommit" 모드로 작동하지만,
파이썬 "sqlite3" 모듈은 기본적으로 그렇지 않습니다.

"autocommit" 모드는 데이터베이스를 수정하는 명령문이 즉시 적용됨을 뜻
합니다. "BEGIN" 이나 "SAVEPOINT" 문은 "autocommit" 모드를 비활성화하고
, 가장 바깥쪽 트랜잭션을 끝내는 "COMMIT", "ROLLBACK" 또는 "RELEASE"는
"autocommit" 모드를 다시 켭니다.

기본적으로 파이썬 "sqlite3" 모듈은 데이터 조작 언어(DML - Data
Modification Language) 문 (즉, "INSERT"/"UPDATE"/"DELETE"/"REPLACE")
앞에 암묵적으로 "BEGIN" 문을 넣습니다.

"connect()" 호출의 *isolation_level* 매개 변수를 통해, 또는 연결의
"isolation_level" 프로퍼티를 통해, "sqlite3"가 묵시적으로 실행하는
"BEGIN" 문의 종류를 제어할 수 있습니다. *isolation_level*을 지정하지
않으면, 단순한 "BEGIN"이 사용되며, 이는 "DEFERRED"를 지정하는 것과 같
습니다. 가능한 다른 값은 "IMMEDIATE" 와 "EXCLUSIVE"입니다.

"isolation_level"를 "None"로 설정하여 "sqlite3" 모듈의 묵시적 트랜잭션
관리를 비활성화할 수 있습니다. 그러면 하부 "sqlite3" 라이브러리가
"autocommit" 모드로 작동합니다. 그런 다음 코드에서 "BEGIN",
"ROLLBACK", "SAVEPOINT" 및 "RELEASE" 문을 명시적으로 실행하여 트랜잭션
상태를 완전히 제어할 수 있습니다.

Note that "executescript()" disregards "isolation_level"; any
transaction control must be added explicitly.

버전 3.6에서 변경: "sqlite3"는 DDL 문 앞에서 열린 트랜잭션을 묵시적으
로 커밋했습니다. 더는 그렇지 않습니다.


효율적으로 "sqlite3" 사용하기
=============================


바로 가기 메서드 사용하기
-------------------------

"Connection" 객체의 비표준 "execute()", "executemany()" 및
"executescript()" 메서드를 사용하면, (종종 불필요한) "Cursor" 객체를
명시적으로 만들 필요가 없으므로, 코드를 더 간결하게 작성할 수 있습니다
. 대신, "Cursor" 객체가 묵시적으로 만들어지며 이러한 바로 가기 메서드
는 커서 객체를 반환합니다. 이런 방법으로, "Connection" 객체에 대한 단
일 호출만 사용하여 "SELECT" 문을 실행하고 직접 이터레이트할 수 있습니
다.

   import sqlite3

   langs = [
       ("C++", 1985),
       ("Objective-C", 1984),
   ]

   con = sqlite3.connect(":memory:")

   # Create the table
   con.execute("create table lang(name, first_appeared)")

   # Fill the table
   con.executemany("insert into lang(name, first_appeared) values (?, ?)", langs)

   # Print the table contents
   for row in con.execute("select name, first_appeared from lang"):
       print(row)

   print("I just deleted", con.execute("delete from lang").rowcount, "rows")

   # close is not a shortcut method and it's not called automatically,
   # so the connection object should be closed manually
   con.close()


인덱스 대신 이름으로 열 액세스하기
----------------------------------

"sqlite3" 모듈의 유용한 기능 중 하나는 행 팩토리로 사용하도록 설계된
내장 "sqlite3.Row" 클래스입니다.

이 클래스로 감싼 행은 인덱스(튜플처럼)와 대소 문자를 구분하지 않는 이
름으로 액세스할 수 있습니다:

   import sqlite3

   con = sqlite3.connect(":memory:")
   con.row_factory = sqlite3.Row

   cur = con.cursor()
   cur.execute("select 'John' as name, 42 as age")
   for row in cur:
       assert row[0] == row["name"]
       assert row["name"] == row["nAmE"]
       assert row[1] == row["age"]
       assert row[1] == row["AgE"]

   con.close()


컨텍스트 관리자로 연결 사용하기
-------------------------------

연결 객체는 트랜잭션을 자동으로 커밋하거나 롤백하는 컨텍스트 관리자로
사용할 수 있습니다. 예외가 발생하면, 트랜잭션이 롤백 됩니다; 그렇지 않
으면 트랜잭션이 커밋 됩니다:

   import sqlite3

   con = sqlite3.connect(":memory:")
   con.execute("create table lang (id integer primary key, name varchar unique)")

   # Successful, con.commit() is called automatically afterwards
   with con:
       con.execute("insert into lang(name) values (?)", ("Python",))

   # con.rollback() is called after the with block finishes with an exception, the
   # exception is still raised and must be caught
   try:
       with con:
           con.execute("insert into lang(name) values (?)", ("Python",))
   except sqlite3.IntegrityError:
       print("couldn't add Python twice")

   # Connection object used as context manager only commits or rollbacks transactions,
   # so the connection object should be closed manually
   con.close()

-[ 각주 ]-

[1] The 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 "--enable-loadable-sqlite-
    extensions" to configure.
