# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT


class Cache(object):

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see help(type(x)) for signature """
    pass

  def display(self):
    """ For debugging only. """
    pass

  def get(self):
    """ Gets an entry from the cache or calls the factory function to produce one. """
    pass

class Connection(object):
  """ SQLite database connection object. """

  DataError = None
  DatabaseError = None
  Error = None
  IntegrityError = None
  InterfaceError = None
  InternalError = None
  NotSupportedError = None
  OperationalError = None
  ProgrammingError = None
  Warning = None

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see help(type(x)) for signature """
    pass

  def close(self):
    """ Closes the connection. """
    pass

  def commit(self):
    """ Commit the current transaction. """
    pass

  def create_aggregate(self):
    """ Creates a new aggregate. Non-standard. """
    pass

  def create_collation(self):
    """ Creates a collation function. Non-standard. """
    pass

  def create_function(self):
    """ Creates a new function. Non-standard. """
    pass

  def cursor(self):
    """ Return a cursor for the connection. """
    pass

  def execute(self):
    """ Executes a SQL statement. Non-standard. """
    pass

  def executemany(self):
    """ Repeatedly executes a SQL statement. Non-standard. """
    pass

  def executescript(self):
    """ Executes a multiple SQL statements at once. Non-standard. """
    pass

  def interrupt(self):
    """ Abort any pending database operation. Non-standard. """
    pass

  isolation_level = property(None, None, None,
                             )


  def iterdump(self):
    """ Returns iterator to the dump of the database in an SQL text format. Non-standard. """
    pass

  def rollback(self):
    """ Roll back the current transaction. """
    pass

  row_factory = None

  def set_authorizer(self):
    """ Sets authorizer callback. Non-standard. """
    pass

  def set_progress_handler(self):
    """ Sets progress handler callback. Non-standard. """
    pass

  text_factory = None
  total_changes = property(None, None, None,
                           )


class Cursor(object):
  """ SQLite database cursor class. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see help(type(x)) for signature """
    pass

  arraysize = None

  def close(self):
    """ Closes the cursor. """
    pass

  connection = None
  description = None

  def execute(self):
    """ Executes a SQL statement. """
    pass

  def executemany(self):
    """ Repeatedly executes a SQL statement. """
    pass

  def executescript(self):
    """ Executes a multiple SQL statements at once. Non-standard. """
    pass

  def fetchall(self):
    """ Fetches all rows from the resultset. """
    pass

  def fetchmany(self):
    """ Fetches several rows from the resultset. """
    pass

  def fetchone(self):
    """ Fetches one row from the resultset. """
    pass

  lastrowid = None

  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

  row_factory = None
  rowcount = None

  def setinputsizes(self):
    """ Required by DB-API. Does nothing in pysqlite. """
    pass

  def setoutputsize(self):
    """ Required by DB-API. Does nothing in pysqlite. """
    pass

class DataError(DatabaseError):

  pass

class DatabaseError(Error):

  pass

class Error(StandardError):

  pass

class IntegrityError(DatabaseError):

  pass

class InterfaceError(Error):

  pass

class InternalError(DatabaseError):

  pass

class NotSupportedError(DatabaseError):

  pass

class OperationalError(DatabaseError):

  pass

class OptimizedUnicode(object):

  cell_contents = property(None, None, None,
                           )


  pass

PARSE_COLNAMES = 2
PARSE_DECLTYPES = 1

class PrepareProtocol(object):

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see help(type(x)) for signature """
    pass

class ProgrammingError(DatabaseError):

  pass

class Row(object):

  def keys(self):
    """ Returns the keys of the row. """
    pass

SQLITE_ALTER_TABLE = 26
SQLITE_ANALYZE = 28
SQLITE_ATTACH = 24
SQLITE_CREATE_INDEX = 1
SQLITE_CREATE_TABLE = 2
SQLITE_CREATE_TEMP_INDEX = 3
SQLITE_CREATE_TEMP_TABLE = 4
SQLITE_CREATE_TEMP_TRIGGER = 5
SQLITE_CREATE_TEMP_VIEW = 6
SQLITE_CREATE_TRIGGER = 7
SQLITE_CREATE_VIEW = 8
SQLITE_DELETE = 9
SQLITE_DENY = 1
SQLITE_DETACH = 25
SQLITE_DROP_INDEX = 10
SQLITE_DROP_TABLE = 11
SQLITE_DROP_TEMP_INDEX = 12
SQLITE_DROP_TEMP_TABLE = 13
SQLITE_DROP_TEMP_TRIGGER = 14
SQLITE_DROP_TEMP_VIEW = 15
SQLITE_DROP_TRIGGER = 16
SQLITE_DROP_VIEW = 17
SQLITE_IGNORE = 2
SQLITE_INSERT = 18
SQLITE_OK = 0
SQLITE_PRAGMA = 19
SQLITE_READ = 20
SQLITE_REINDEX = 27
SQLITE_SELECT = 21
SQLITE_TRANSACTION = 22
SQLITE_UPDATE = 23

class Statement(object):

  pass

class Warning(StandardError):

  pass

__doc__ = None
__file__ = '/home/shared/src/ide/build-files/build-temp/runtimes-release/__os__/linux-x64/runtime-python2.7/lib/python2.7/lib-dynload/_sqlite3.so'
__name__ = '_sqlite3'
__package__ = None

def adapt(obj, protocol, alternate):
  """ adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard. """
  return None

adapters = {}

def complete_statement(sql):
  """ complete_statement(sql)
  
  Checks if a string contains a complete SQL statement. Non-standard. """
  pass

def connect(database, timeout=None, isolation_level=None, detect_types=None, factory=None):
  """ connect(database[, timeout, isolation_level, detect_types, factory])
  
  Opens a connection to the SQLite database file *database*. You can use
  ":memory:" to open a database connection to a database that resides in
  RAM instead of on disk. """
  pass

converters = {}

def enable_callback_tracebacks(flag):
  """ enable_callback_tracebacks(flag)
  
  Enable or disable callback functions throwing errors to stderr. """
  pass

def enable_shared_cache(do_enable):
  """ enable_shared_cache(do_enable)
  
  Enable or disable shared cache mode for the calling thread.
  Experimental/Non-standard. """
  pass

def register_adapter(type, callable):
  """ register_adapter(type, callable)
  
  Registers an adapter with pysqlite's adapter registry. Non-standard. """
  pass

def register_converter(typename, callable):
  """ register_converter(typename, callable)
  
  Registers a converter with pysqlite. Non-standard. """
  pass

sqlite_version = '3.30.1'
version = '2.6.0'