# Database access

    if hasattr(cur, 'query'): raw_query = cur.query

    elif hasattr(cur, '_last_executed'): raw_query = cur._last_executed

    if raw_query != None: return raw_query

    '''For params, see get_cur_query()'''

    def __init__(self, name, cause=None):

            +strings.as_tt(strings.ustr(name)), cause)

    def __init__(self, value, cause=None):

            +strings.as_tt(strings.urepr(value)), cause)

    def __init__(self, type_, name, cause=None):

            type_))+'; name: '+strings.as_tt(name), cause)

        self.name = name

        msg = 'Violated '+strings.as_tt(name)+' constraint'

        DbException.__init__(self, msg, cause)

        msg = 'Missing cast to type '+strings.as_tt(type_)

        if col != None: msg += ' on column: '+strings.as_tt(col)

        DbException.__init__(self, msg, cause)

        self.col = col

class DbWarning(UserWarning): pass

def col_names(cur): return (col[0] for col in cur.description)

def rows(cur): return iter(lambda: cur.fetchone(), None)

def consume_rows(cur):

    '''Used to fetch all rows so result will be cached'''

    iters.consume_iter(rows(cur))

def next_row(cur): return rows(cur).next()

def row(cur):

    row_ = next_row(cur)

    consume_rows(cur)

    return row_

def next_value(cur): return next_row(cur)[0]

def value(cur): return row(cur)[0]

def values(cur): return iters.func_iter(lambda: next_value(cur))

def value_or_none(cur):

    try: return value(cur)

    except StopIteration: return None

    if module == 'psycopg2' or module == None: quote = '"'

    else: raise NotImplementedError("Can't escape name for "+module+' database')

def esc_name_by_engine(engine, name, **kw_args):

    return esc_name_by_module(db_engines[engine][0], name, **kw_args)

def esc_name(db, name, **kw_args):

    return esc_name_by_module(util.root_module(db.db), name, **kw_args)

def qual_name(db, schema, table):

    def esc_name_(name): return esc_name(db, name)

    table = esc_name_(table)

    if schema != None: return esc_name_(schema)+'.'+table

    else: return table

    'MySQL': ('MySQLdb', {'password': 'passwd', 'database': 'db'}),

    'PostgreSQL': ('psycopg2', {}),

}

DatabaseErrors_set = set([DbException])

DatabaseErrors = tuple(DatabaseErrors_set)

def _add_module(module):

    DatabaseErrors_set.add(module.DatabaseError)

    global DatabaseErrors

    DatabaseErrors = tuple(DatabaseErrors_set)

def db_config_str(db_config):

    return db_config['engine']+' database '+db_config['database']

        @param debug_temp Whether temporary objects should instead be permanent.

            This assists in debugging the internal objects used by the program.

            query, to help identify the data source in pg_stat_activity.

        self.caching = caching

        self.profile_row_ct = None

    def __getattr__(self, name):

        if name == '__dict__': raise Exception('getting __dict__')

        if name == 'db': return self._db()

        else: raise AttributeError()

    def __getstate__(self):

        state = copy.copy(self.__dict__) # shallow copy

        return state

        self.__db = None

        # Do not do this in test mode as it would roll back everything

        if self.autocommit: self.close()

        # Connection will be reopened automatically on first query

        if self.__db == None:

            # Process db_config

            db_config = self.db_config.copy() # don't modify input!

            module = __import__(module_name)

            _add_module(module)

            for orig, new in mappings.iteritems():

                try: util.rename_key(db_config, orig, new)

                except KeyError: pass

            # Connect

            self.__db = module.connect(**db_config)

            self._savepoint += 1

                import psycopg2.extensions

                self.db.set_isolation_level(

                    psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED)

                search_path.append(value(run_query(self, 'SHOW search_path',

                    log_level=4)))

                run_query(self, 'SET search_path TO '+(','.join(search_path)),

                    log_level=3)

        return self.__db

                self.result = e # cache the exception as the result

                self._cache_result()

                raise

            # Always cache certain queries

                # so don't cache ADD COLUMN unless it has distinguishing comment

                if query.find('ADD COLUMN') < 0 or query.endswith('*/'):

            row = self.inner.fetchone()

            # otherwise, fetched all rows

            return row

        def _cache_result(self):

            # inserts are not idempotent. Other non-SELECT queries don't have

            # their result set read, so only exceptions will be cached (an

            # invalid query will always be invalid).

                    util.dict_subset(dicts.AttrsDictView(self),

                    ['query', 'result', 'rowcount', 'description']))

            def __init__(self, cached_result): self.__dict__ = cached_result

                # otherwise, result is a rows list

                self.iter = iter(self.result)

            def fetchone(self):

                try: return self.iter.next()

                except StopIteration: return None

        except NotImplementedError, e:

            module = util.root_module(self.db)

            if module == 'MySQLdb':

                import _mysql

                str_ = _mysql.escape_string(value)

            else: raise e

        '''Standardizes SQL code.

        * Ensures that string literals are prefixed by `E`

        '''

        if str_.startswith("'"): str_ = 'E'+str_

        return str_

        if self.can_mogrify(): return self.db.cursor().mogrify(query, params)

        else: raise NotImplementedError("Can't mogrify query")

        encoding_str = sql_gen.Literal(encoding)

        run_query(self, 'SET NAMES '+encoding_str.to_str(self))

            for msg in self.db.notices:

                if msg not in self._notices_seen:

                    self._notices_seen.add(msg)

                    self.log_debug(msg, level=2)

            throws one of these exceptions.

            this instead of being output. This allows you to filter log messages

            depending on the result of the query.

            profiler = profiling.ItersProfiler(start_now=True, iter_text='row')

            if cacheable:

            # Run query

                _add_cursor_info(e, self, query)

                raise

                ## Log or return query

                query = query.replace('\t', '\n', 1)

                elif cacheable: msg += 'cache miss'

                else: msg += 'non-cacheable'

                else: self.log_debug(msg, log_level)

                self.print_notices()

        return cur

        prev_isolation_level = self.db.isolation_level

            psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)

        self._savepoint += 1

        else: query = 'SAVEPOINT '+savepoint

        self.run_query(query, log_level=4)

        try:

            return func()

            if top: self.run_query('COMMIT', log_level=4)

            else: query = 'ROLLBACK TO SAVEPOINT '+savepoint

            self.run_query(query, log_level=4)

            # Always release savepoint, because after ROLLBACK TO SAVEPOINT,

            # "The savepoint remains valid and can be rolled back to again"

            # (http://www.postgresql.org/docs/8.3/static/sql-rollback-to.html).

                self.run_query('RELEASE SAVEPOINT '+savepoint, log_level=4)

            self._savepoint -= 1

            assert self._savepoint >= 0

                profiler.stop(self.profile_row_ct)

    def do_autocommit(self):

        '''Autocommits if outside savepoint'''

        if self.autocommit and self._savepoint == 1:

            'column_default', sql_gen.Cast('boolean',

            sql_gen.Col('is_nullable'))]

            ('column_name', strings.ustr(col.name))]

        if schema != None: conds.append(('table_schema', schema))

            cacheable=cacheable, log_level=4) # TODO: order by search_path order

            type_ = sql_gen.ArrayType(strings.remove_prefix('_', extra_type,

                require=True))

        return sql_gen.TypedCol(col.name, type_, default, nullable)

    def TempFunction(self, name):

        if self.debug_temp: schema = None

        else: schema = 'pg_temp'

        return sql_gen.Function(name, schema)

    msg = strings.ustr(e.args[0])

    msg = re.sub(r'^(?:PL/Python: )?ValueError: ', r'', msg)

    match = re.match(r'^invalid byte sequence for encoding "(.+?)":', msg)

    if match:

        encoding, = match.groups()

        raise EncodingException(encoding, e)

    match = re.match(r'^duplicate key value violates unique constraint "(.+?)"',

        msg)

    if match:

        constraint, = match.groups()

        cols = []

        cond = None

        if recover: # need auto-rollback to run index_cols()

            try:

                cols = index_cols(db, constraint)

                cond = index_cond(db, constraint)

            except NotImplementedError: pass

        raise DuplicateKeyException(constraint, cond, cols, e)

    match = re.match(r'^null value in column "(.+?)" violates not-null'

        r' constraint', msg)

    if match:

        col, = match.groups()

        raise NullValueException('NOT NULL', None, [col], e)

    match = re.match(r'^new row for relation "(.+?)" violates check '

        r'constraint "(.+?)"', msg)

    if match:

        table, constraint = match.groups()

        constraint = sql_gen.Col(constraint, table)

        cond = None

        if recover: # need auto-rollback to run constraint_cond()

            try: cond = constraint_cond(db, constraint)

            except NotImplementedError: pass

        raise CheckException(constraint.to_str(db), cond, [], e)

        value, = match.groups()

        raise InvalidValueException(value, e)

    match = re.match(r'^column "(.+?)" is of type (.+?) but expression '

        r'is of type', msg)

    if match:

        col, type_ = match.groups()

        raise MissingCastException(type_, col, e)

    match = re.match(r'^could not determine polymorphic type because '

        r'input has type "unknown"', msg)

    if match: raise MissingCastException('text', None, e)

    if match:

        type0, type1 = match.groups()

        raise MissingCastException(type0, None, e)

    match = re.match(typed_name_re+r'.*? already exists', msg)

    if match:

        type_, name = match.groups()

        raise DuplicateException(type_, name, e)

    match = re.match(r'more than one (\S+) named ""(.+?)""', msg)

    if match:

        type_, name = match.groups()

        raise DuplicateException(type_, name, e)

    match = re.match(typed_name_re+r' does not exist', msg)

    if match:

        type_, name = match.groups()

                    raise MissingCastException(type_, None, e)

    raise # no specific exception raised

    log_ignore_excs=None, **kw_args):

    log_ignore_excs = tuple(log_ignore_excs)