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


class Binary(object):
  """ buffer(object [, offset[, size]])
  
  Create a new buffer object which references the given object.
  The buffer will reference a slice of the target object from the
  start of the object (or at the specified offset). The slice will
  extend to the end of the target object (or with the specified size). """

  pass

class Cache(object):

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ 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 x.__class__.__doc__ 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 x.__class__.__doc__ 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 Date(object):
  """ date(year, month, day) --> date object """

  def ctime(self):
    """ Return ctime() style string. """
    pass

  day = property(None, None, None,
                 )


  def fromordinal(self, int):
    """ int -> date corresponding to a proleptic Gregorian ordinal. """
    return None

  def fromtimestamp(self, timestamp):
    """ timestamp -> local date from a POSIX timestamp (like time.time()). """
    return None

  def isocalendar(self):
    """ Return a 3-tuple containing ISO year, week number, and weekday. """
    pass

  def isoformat(self):
    """ Return string in ISO 8601 format, YYYY-MM-DD. """
    pass

  def isoweekday(self, arg0):
    """ Return the day of the week represented by the date.
    Monday == 1 ... Sunday == 7 """
    return None

  max = None
  min = None
  month = property(None, None, None,
                   )


  def replace(self):
    """ Return date with new specified fields. """
    pass

  resolution = None

  def strftime(self, format):
    """ format -> strftime() style string. """
    return ""

  def timetuple(self):
    """ Return time tuple, compatible with time.localtime(). """
    pass

  def today(self, arg0):
    """ Current date or datetime:  same as self.__class__.fromtimestamp(time.time()). """
    pass

  def toordinal(self):
    """ Return proleptic Gregorian ordinal.  January 1 of year 1 is day 1. """
    pass

  def weekday(self, arg0):
    """ Return the day of the week represented by the date.
    Monday == 0 ... Sunday == 6 """
    return None

  year = property(None, None, None,
                  )


def DateFromTicks(ticks):
  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 x.__class__.__doc__ for signature """
    pass

class ProgrammingError(DatabaseError):

  pass

class Row(object):

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

  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

Time = time
def TimeFromTicks(ticks):
  pass

Timestamp = datetime
def TimestampFromTicks(ticks):
  pass

class Warning(StandardError):

  pass

__builtins__ = {}
__doc__ = None
__file__ = 'C:\\src\\ide\\build-files\\build-temp\\runtimes-release\\__os__\\win32\\runtime-python2.6\\lib\\sqlite3\\__init__.pyc'
__name__ = 'sqlite3'
__package__ = 'sqlite3'
__path__ = []

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

adapters = {}
apilevel = '2.0'

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 = {}
datetime = None
dbapi2 = None

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

paramstyle = 'qmark'

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.5.9'
sqlite_version_info = ()
threadsafety = 1
time = None
version = '2.4.1'
version_info = ()
x = '9'