# 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

    else: return repr(input_query)+' % '+repr(input_params)

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

    exc.add_msg(e, 'query: '+str(get_cur_query(*args, **kw_args)))

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

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

        DbException.__init__(self,

        self.value = value

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

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

def check_name(name):

    if re.search(r'\W', name) != None: raise NameException('Name "'+name

        +'" may contain only alphanumeric characters and _')

def esc_name_by_module(module, name, ignore_case=False):

    if module == 'psycopg2':

        if ignore_case:

            # Don't enclose in quotes because this disables case-insensitivity

            check_name(name)

            return name

        else: quote = '"'

    elif module == 'MySQLdb': quote = '`'

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

    return quote + name.replace(quote, '') + quote

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']

        caching=True, log_debug=log_debug_none):

        self.serializable = serializable

        self.caching = caching

        self.__db = 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

        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)

            # Configure connection

                'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE')

                schemas_ = ''.join((esc_name(self, s)+', '

                    for s in schemas.split(',')))

                run_raw_query(self, "SELECT set_config('search_path', \

%s || current_setting('search_path'), false)", [schemas_])

        return self.__db

                    return_value = self.inner.execute(query, params)

                    self.outer.do_autocommit()

                self._cache_result()

                raise

            if self.rowcount == 0 and not self._is_insert: consume_rows(self)

            row = self.inner.fetchone()

            # otherwise, fetched all rows

            return row

        def _cache_result(self):

            # idempotent, but an invalid insert 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

        if module == 'psycopg2': return self.db.cursor().mogrify('%s', [value])

            import _mysql

            return _mysql.escape_string(value)

        else: raise NotImplementedError("Can't escape value for "+module

            +' database')

        See self.DbCursor.execute().'''

        try:

            if cacheable:

                query_lookup = _query_lookup(query, params)

                try:

                    cur = self.query_results[query_lookup]

                    used_cache = True

                except KeyError: cur = self.DbCursor(self)

            else: cur = self.db.cursor()

            # Run query

                elif cacheable: cache_status = 'Cache miss'

                else: cache_status = 'Non-cacheable'

        return cur

    def is_cached(self, query, params=None):

        return _query_lookup(query, params) in self.query_results

    def with_savepoint(self, func):

        self._savepoint += 1

        try:

            try: return_val = func()

            finally:

                self._savepoint -= 1

                assert self._savepoint >= 0

        except:

            self.run_query('ROLLBACK TO SAVEPOINT '+savepoint)

            raise

        else:

            self.run_query('RELEASE SAVEPOINT '+savepoint)

    def do_autocommit(self):

        '''Autocommits if outside savepoint'''

        assert self._savepoint >= 0

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

            self.log_debug('Autocommiting')

            self.db.commit()

    module = util.root_module(db.db)

    if module == 'psycopg2': return db.db.cursor().mogrify(query, params)

    else: raise NotImplementedError("Can't mogrify query for "+module+

        ' database')

        def run(): return run_raw_query(db, query, params, cacheable)

        if recover and not db.is_cached(query, params):

            return with_savepoint(db, run)

        else: return run() # don't need savepoint if cached

    except Exception, e:

        if not recover: raise # need savepoint to run index_cols()

            r'"((_?[^\W_]+)_[^"]+)"', msg)

        if match:

            constraint, table = match.groups()

            try: cols = index_cols(db, table, constraint)

            except NotImplementedError: raise e

            else: raise DuplicateKeyException(cols, e)

                strings.to_unicode(match.group(1)), e)

        if match: raise DuplicateTableException(match.group(1), e)

        if match: raise DuplicateFunctionException(match.group(1), e)

    '''Prepends the version # so it won't be removed if the name is truncated'''

    if match:

        version = int(match.group(1))+1

        name = match.group(2)

    return 'v'+str(version)+'_'+name

    For params, see run_query().

    '''

        while True:

            try:

                if not db.debug: create_query += ' TEMP'

                create_query += ' TABLE '+into_ref[0]+' AS '+query

                return run_query(db, create_query, params, *args, **kw_args)

            except DuplicateTableException, e:

                into_ref[0] = next_version(into_ref[0])

                # try again with next version of name

        joins has the format: dict(right_col=left_col, ...)

        * if left_col is join_using, left_col is set to right_col

        * if left_col is filter_out, the tables are LEFT JOINed together and the

          query is filtered by `right_col IS NULL` (indicating no match)

        * compare_left_side: Code|str (for col name)

        * compare_right_side: ValueCond|literal value

        use all columns

    if not table_is_esc: table0 = esc_name_(table0)

            assume_col=True).to_str(db)

    # DISTINCT ON columns

    # Columns

    query += ' '

    # Main table

    left_table = table0

    for table, joins in tables:

        if not table_is_esc: table = esc_name_(table)

                # Can't use join_using because the columns being joined can have

                # different values in a LEFT JOIN.

                # Use '~=' because it's OK to pass NULLs through.

                joins[right] = sql_gen.CompareCond(sql_gen.col2sql_gen(right,

                    left_table, table_is_esc), '~=')

                conds[(table, right)] = None # filter query by no match

                # for None values, tuple is optional

                sql_gen.cond2sql_gen(left_col, left_table, table_is_esc,

                    assume_col=True)))

        else: join_cond = 'ON '+(' AND '.join(map(join, joins.iteritems())))

        query += ' ORDER BY '+sql_gen.col2sql_gen(order_by, table0,

            table_is_esc).to_str(db)

    if start != None:

        if start != 0: query += ' OFFSET '+str(start)

        missing = False

    if missing: warnings.warn(DbWarning(

        'SELECT statement missing a WHERE, LIMIT, or OFFSET clause: '+query))

    '''For params, see mk_select() and run_query()'''

    recover = kw_args.pop('recover', None)

    cacheable = kw_args.pop('cacheable', True)

    query, params = mk_select(db, *args, **kw_args)

    return run_query(db, query, params, recover, cacheable)

    @param returning str|None An inserted column (such as pkey) to return

        query will be fully cached, not just if it raises an exception.

    '''

    if cols == []: cols = None # no cols (all defaults) = unknown col names

    # Build query

    query = 'INSERT INTO '+table

    if cols != None:

        map(check_name, cols)

        query += ' ('+', '.join(cols)+')'

    query += ' '+select_query

    if returning != None:

        check_name(returning)

        query += ' RETURNING '+returning

        # Create function

            try:

                if not db.debug: function = 'pg_temp.'+function

CREATE FUNCTION '''+function+'''() RETURNS '''+return_type+'''

    AS $$'''+mogrify(db, query, params)+''';$$;

'''

                break # this version was successful

            except DuplicateFunctionException, e:

                function_name = next_version(function_name)

                # try again with next version of name

        # Return query that uses function

            order_by=None, table_is_esc=True)# AS clause requires function alias

def insert_select(db, *args, **kw_args):

    if into_ref != None: kw_args['embeddable'] = True

    cacheable = kw_args.pop('cacheable', True)

    query, params = mk_insert_select(db, *args, **kw_args)

        cacheable=cacheable)