OO for db connection

class User:
    def __init__(self,username,password):
        self.username = username
        self.password = password

    def addUser(self,username,password):
        mysql = MySQL() # I can put the db connection in the constructor
        mysql.executeQuery("Insert ....... ")
        mysql.close()

    def removeUser(self,id)
        mysql = MySQL()
        mysql.executeQuery("Delete ....... ")
        mysql.close()

class User:
    def __init__(self,username,password):
        self.username = username
        self.password = password
        self.mysql = MySQL() # db connection in the constructor

    def addUser(self,username,password):
        self.mysql.executeQuery("Insert ....... ")

    def removeUser(self,id)
        self.mysql.executeQuery("Delete ....... ")

class controller:
    def __init__(...):
        ....
    def addUser(...):

        user = User() # connection to mysql initiated in __init__ method of user class
        user.addUser(name='blah')
        user.deleteUser(id=7)
        # end of method, so user object deleted, and so the mysql wrapper 
        # class instance which was a class variable of user is detled, so 
        # would like to auto disconnect when mysql class instance is deleted

    def someothermethod():

#!/usr/bin/python

class MyTest:

  def __init__(self):
    print "object created"

  def __del__(self):
    print "object deleted"



def fn():

  t = MyTest()
  raw_input('type something and then test will delete')


if __name__=="__main__":
  raw_input('press enter to enter function')
  fn()
  raw_input('fn finished, press enter to end prog')

class DB {
   function DB() {
       $this->host = "mysql.host.com";
       $this->db = "myDatabase";
       $this->user = "root";
       $this->pass = "mysql";
       $this->link = mysql_connect($this->host, $this->user, $this->pass);
       mysql_select_db($this->db);
       register_shutdown_function($this->close);
   }
   function close() {
       mysql_close($this->link);
   }
}

'register_shutdown_function($this->close);'

 function __destructor() {
    $this->close
 }

#!/usr/bin/env python

import MySQLdb

class mySQL:
	
	def __init__(self, host, username, password, database):
		self.connection = MySQLdb.connect(host, username, password, database)
		self.cursor = self.connection.cursor()
	
	def query(self, SQL):
		self.cursor.execute(SQL)
		result = self.cursor.fetchall()
		return result
		
	def __del__(self):
		self.cursor.close()
		self.connection.close()

#!/usr/bin/python

import MySQLdb
import MySQLdb.cursors


# EXAMPLE USAGE
# -------------
# 
# SELECT
# ------
# import MySql
# mysql = MySql()
# mysql.query("SELECT field FROM table")
# if mysql.numrows() > 0:
#     while mysql.movenext():
#         print mysql.getfield("field")
#
# INSERT
# ------
# import MySql
# mysql = MySql()
# mysql.query("INSERT INTO table (field) values ('value')")
#
# UPDATE
# ------
# import MySql
# mysql = MySql()
# mysql.query("UPDATE table SET field='newvalue' WHERE fieldID=1")
# 
# DELETE
# ------
# import MySql
# mysql = MySql()
# mysql.query("DELETE FROM table WHERE fieldID=1")


class MySql:

    def __init__(self, host='localhost', username='', password='', database='test'):
        """constructor: open the connection and a get a handle"""

        print "constructing...",
        self.connection = MySQLdb.connect(host, username, password, database)
        self.cursor = self.connection.cursor(cursorclass=MySQLdb.cursors.DictCursor)
        print "constructed"


    def query(self, SQL):
        """ execute the query"""

        self.cursor.execute(SQL)
        self.currentRecord = None


    def numrows(self):
        """return the total number of rows in the resultset"""

        return self.cursor.rowcount


    def movenext(self):
        """move foreward a row and return whether we reached end of result set"""

        self.currentRecord = self.cursor.fetchone()
        return self.currentRecord is not None


    def getfield(self,field):
        """return the field value from the current row"""

        return self.currentRecord[field]


    def __del__(self):
        """destructor: close the handle and connection before destruction"""

        print "destructing...",
        self.cursor.close()
        self.connection.close()
        print "destructed"

#!/usr/bin/python
from __future__ import generators

class T:

        class T_Iter:
                def __init__(self,obj):
                        self.obj = obj
                        self.pos = -1
                def movenext(self):
                        self.pos += 1
                        return self.pos < len(self.obj)
                def val(self):
                        return self.obj[self.pos]

        def __init__(self):
                self.arr = [1,2,3,4]

        def __iter__(self):
                return self.T_Iter(self.arr)

        def generator1(self):
                ## can make the result from db local here
                ## by doing result = self.executeQuery(sql)
                result = self.arr
                for row in result:
                        yield row

        def generator2(self):
                pos = 0
                while pos < len(self.arr):
                        yield self.arr[pos]
                        pos += 1


def fn1():
        t = T()
        iter = t.__iter__()
        while iter.movenext():
                print iter.val()

def fn2():
        t = T()
        for elem in t.generator1():
                print elem

def fn3():
        t = T()
        for elem in t.generator2():
                print elem

fn1()
fn2()
fn3()