import psycopg2

import psycopg2.extensions

import psycopg2.extras

class DatabaseError(Exception):

    def __init__(self, msg, query=None):

        self.query = query

        Exception.__init__(self, msg)

class BadConnectionError(Exception):

    pass

class Row(dict):

    def __getattr__(self, key):

        return self[key]

class Database:

    def __init__(self):

        # pool of database connections

        # indexed by conninfo, items are lists of connections

        self.pool = {}

        # number of unused connections per conninfo to keep open

        self.pool_keep_open = 1

    def __del__(self):

        for conninfo in self.pool.keys():

            for conn in self.pool[conninfo]:

                conn.close()

    def connect(self, conninfo):

        try:

            conn = psycopg2.connect(conninfo, async=1)

            psycopg2.extras.wait_select(conn)

        except psycopg2.DatabaseError, e:

            raise DatabaseError(str(e))

        return conn

    def get_conn(self, conninfo):

        if not conninfo in self.pool:

            self.pool[conninfo] = []

            return self.connect(conninfo)

        else:

            conn = None

            while len(self.pool[conninfo]) and conn is None:

                conn = self.pool[conninfo].pop()

                if conn.closed:

                    conn = None

            if conn is None:

                return self.connect(conninfo)

        return conn

    def put_conn(self, conninfo, conn):

        if len(self.pool[conninfo]) >= self.pool_keep_open:

            conn.close()

        else:

            self.pool[conninfo].append(conn)

    def execute(self, q, args=[]):

        conn = self.get_conn()

        try:

            curs = conn.cursor()

            curs.execute(q, args)

            psycopg2.extras.wait_select(curs.connection)

#            conn.commit()

        except psycopg2.OperationalError, e:

            # disconnected?

#            conn.rollback()

            conn.close()

            raise BadConnectionError(str(e))

        except psycopg2.DatabaseError, e:

#            conn.rollback()

            raise DatabaseError(str(e), curs.query)

        return curs

    def finish(self, curs):

        self.put_conn(curs.connection)

    def row(self, curs, row):

        return Row(zip([x[0] for x in curs.description], row))

    def fetchone(self, curs):

        return self.row(curs, curs.fetchone())

    def fetchall(self, curs):

        rows = curs.fetchall()

        return [self.row(curs, row) for row in rows]