Connecting Tech Pros Worldwide Help | Site Map
bytes > topic > python > insights

Database Login now uses mxODBC

  #1  
Old March 12th, 2007, 03:45 AM
bartonc's Avatar
Moderator
  
Join Date: Sep 2006
Location: Minden, Nevada, USA
Posts: 6,400
With one small change to the view/control:
Expand|Select|Wrap|Line Numbers
  1.         self.staticText3 = wx.StaticText(id=wxID_DBCONNECTDIALOGSTATICTEXT3,
  2.                 label='ODBC Data Source Name', name='staticText3', parent=self, pos=wx.Point(240,
  3.                 40), size=wx.Size(143, 16), style=0)
and some rework of the model:
Expand|Select|Wrap|Line Numbers
  1. ##from MySQLdb import *
  2. from mx.ODBC.Windows import *
  3. from time import time
  4.  
  5. class DBServer:
  6.     def __init__(self, master):
  7.         self.master = master
  8.  
  9.     def Login(self, servername, username, password):    #, database=""
  10.         """Attempt to create a database login. If successful, return
  11.            an open connection. Otherwise, return None."""
  12.         try:
  13.             self.dbconnect = Connect(servername, user=username, password=password,
  14.                                      clear_auto_commit=0) #, host=servername
  15. ##            self.dbconnect = connect(host=servername, user=username, passwd=password)   #, db=database
  16.         except (DatabaseError, OperationalError):
  17.             self.dbconnect = None
  18.             self.dbcursor = None
  19.             self.master.write('Couldn\'t log on to the server `%s` as `%s`\n' %(servername, username))
  20.             return
  21.         self.master.write("%s has been logged onto %s\n" %(username, servername))
  22.         self.dbcursor = self.dbconnect.cursor()
  23.         self.Execute('SET autocommit=1')
  24.         return self.dbconnect
  25.  
  26.     def DBError(self, query, message):
  27.         """Remove the current message from the cursor
  28.            and display it. Report the query and error to the master."""
  29.         print message
  30. ##        try:
  31. ##            (error, message) = self.dbcursor.messages.pop()
  32. ##        except AttributeError:
  33. ##            (error, message) = self.dbconnect.messages.pop()
  34. ##        self.master.write('%s\n%s #%d:  %s\n' %(query, str(error).split('.')[-1],
  35. ##                                                message[0], message[1]))
  36.         self.master.write('%s\nOCDB Error %s #%d:  %s #%d\n' %(query, message[0], message[1],
  37.                           message[-2].split(']')[-1], message[-1]))
  38.  
  39.     def IsOpen(self, connection):
  40.         return not connection.closed
  41.  
  42.     def Execute(self, query):
  43.         """Execution method reports on the number of rows affected and duration
  44.            of the database query execution and catches errors. Return a reference
  45.            to the cursor if no error ocurred, otherwise, None."""
  46.         cursor = self.dbcursor
  47.         if cursor:
  48.             try:
  49.                 now = time()
  50.                 cursor.execute(query)
  51.                 nRows = cursor.rowcount
  52.                 self.master.write("%s   " % query)
  53.                 self.master.write("%d rows affected: %.2f sec.\n" %(nRows, time() - now))
  54.             except (DatabaseError, OperationalError), message:
  55.                 self.DBError(query, message)
  56.                 return
  57.             return cursor
  58.  
  59.     def DBExists(self, database):
  60.         """Return True if database exists"""
  61.         cursor = self.Execute("show databases")
  62.         if cursor:
  63.             rows = cursor.fetchall()
  64.             return (database.strip('`').lower(),) in rows
  65.  
  66.     def TableExists(self, table):
  67.         """Return True if database exists"""
  68.         cursor = self.Execute("show tables")
  69.         if cursor:
  70.             rows = cursor.fetchall()
  71.             return (table.strip('`').lower(),) in rows
  72.  
  73.     def SetMaster(self, master):
  74.         """Allow the master to be reset."""
  75.         self.master = master
  76.  
  77.     def GetMaster(self):
  78.         return self.master
  79.  
  80.     def GetDbConnection(self):
  81.         return self.dbconnect
  82.  
  83.     def close(self):
  84.         try:
  85.             self.dbconnect.close()
  86.             self.master.write("Closed connection.\n")
  87.         except ProgrammingError:
  88.             self.master.write("Already closed!\n")
  89.  
  90.  
  91. class DBClient:
  92.     """Subclass this class and override the write() method,
  93.        or provide these minimal services in your own class."""
  94.     def __init__(self, database):
  95.         ## Connect to the SQL data base
  96.         self.dbServer = DBServer(self, database)
  97.  
  98.     def write(self, message):
  99.         print message
  100.  
  101.  
  102.  
  103. ## Probably don't want to give default values to parameters in utility routines...
  104. ## Do some tests some day to look at side effects...
  105.  
  106. def MySQLDelete(table, argdict={}, **kwargs):
  107.     """Build an SQL DELETE command from the arguments:
  108.     Return a single string which can be 'execute'd.
  109.     argdict and kwargs are two way to evaluate 'colName':value
  110.     for the WHERE clause."""
  111.     args = argdict.copy()
  112.     args.update(kwargs)
  113.     for key, value in args.items():
  114.         args[key] = (str(value), repr(value))[type(value) == str]
  115.     b = ''
  116.     if args:
  117.         b = 'WHERE %s' % ' AND '.join(key + '=' + value
  118.                                       for key, value in args.items())
  119.     return ' '.join(['DELETE FROM', table, b])
  120.  
  121. def MySQLInsert(table, argdict={}, **kwargs):
  122.     """Build an SQL INSERT command from the arguments:
  123.     Return a single string which can be 'execute'd.
  124.     argdict is a dictionary of 'column_name':value items.
  125.     **kwargs is the same but passed in as column_name=value"""
  126.     args = argdict.copy()   # don't modify caller dictionary!
  127.     args.update(kwargs)
  128.     keys = args.keys()
  129.     argslist = []
  130.     for key in keys:
  131.         a = args[key]
  132.         argslist.append((str(a), repr(a))[type(a) == str])
  133.     # wrap comma separated values in parens
  134.     a = '(%s)' %', '.join(field for field in keys)
  135.     b = '(%s)' %', '.join(argslist)
  136.     return ' '.join(['INSERT', table, a, 'VALUES', b])
  137.  
  138.  
  139. def MySQLUpdate(table, valuedict, argdict={}, **kwargs):
  140.     """Build an SQL SELECT command from the arguments:
  141.     Return a single string which can be 'execute'd.
  142.     valuedict is a dictionary of column_names:value to update.
  143.     argdict and kwargs are two way to evaluate 'colName'=value
  144.     for the WHERE clause."""
  145.     vargs = valuedict.copy()
  146.     for key, value in vargs.items():
  147.         vargs[key] = (str(value), repr(value))[type(value) == str]
  148.     a = 'SET %s' % ', '.join(key + '=' + value
  149.                                   for key, value in vargs.items())
  150.     args = argdict.copy()
  151.     args.update(kwargs)
  152.     for key, value in args.items():
  153.         args[key] = (str(value), repr(value))[type(value) == str]
  154.     b = ''
  155.     if args:
  156.         b = 'WHERE %s' % ' AND '.join(key + '=' + value
  157.                                       for key, value in args.items())
  158.  
  159.     return ' '.join(['UPDATE', table, a, b])
  160.  
  161.  
  162. def MySQLSelect(table, arglist=[], argdict={}, **kwargs):
  163.     """Build an SQL SELECT command from the arguments:
  164.     Return a single string which can be 'execute'd.
  165.     arglist is a list of strings that are column names to get.
  166.     argdict and kwargs are two way to evaluate 'colName'=value
  167.     for the WHERE clause"""
  168.     a = ', '.join(arglist)
  169.     args = argdict.copy()
  170.     args.update(kwargs)
  171.     for key, value in args.items():
  172.         args[key] = (str(value), repr(value))[type(value) == str]
  173.     b = ''
  174.     if args:
  175.         b = 'WHERE %s' % ' AND '.join(key + '=' + value
  176.                                       for key, value in args.items())
  177.  
  178.     return ' '.join(['SELECT', (a or '*'), 'FROM', table, b])
  179.  
  180.  
  181. def Py2SQL_Join(tables, mapping, *arglist, **kwargs):
  182.     """Build an SQL SELECT command from the arguments:
  183.     Return a single string which can be 'execute'd.
  184.     tables is a list of strings that are table names to get from.
  185.     mapping is a list of tuples that maps table[:] to arglist[]
  186.     arglist is a list of strings that are column names to get.
  187.     argdict and kwargs are two way to evaluate 'colName'=value
  188.     for the WHERE clause. There may be a way to map this dict,
  189.     but for now, keys must be unique across tables."""
  190.  
  191.     a = ', '.join(['%s.%s' %(tables[mapping[i][0]], arglist[mapping[i][1]]) for i in range(len(mapping))])
  192.  
  193.     for key, value in kwargs.items():
  194.         kwargs[key] = (str(value), repr(value))[type(value) == str]
  195.     b = ', '.join(tables)
  196.  
  197.  
  198.     # this is just wrong! it randomly pops from dict, and using tables[1] doesn't make sense!
  199.     try:
  200.         k, v = kwargs.popitem()
  201.     except KeyError:
  202.         k = ''
  203.     if k:
  204.         kwargs.update({'%s.%s' %(tables[1], k):v})
  205. #    kwargs.update({'%s.%s' %(tables[0], priKeyName):'%s.%s' %(tables[1], priKeyName)})
  206.  
  207.  
  208.     c = ''
  209.     if kwargs:
  210.         c = 'WHERE %s' % ' AND '.join(key + '=' + value
  211.                                       for key, value in kwargs.items())
  212.  
  213.     return ' '.join(['SELECT', (a or '*'), 'FROM', b, c])
  214.  
  215. if __name__ == "__main__":
  216.     pass
  217. ##    import sys
  218. ##    db = DBServer(sys.stdout)
  219. ##
  220. ##    con = db.Login('genesis', 'joe', 'password')
  221. ##    print con
  222. ##    print db.IsOpen(con)
Any DB can be accessed.



Reply

« previous insight | next insight »

/bytes/development

/bytes/it

/bytes/about

We are a network of experts and professionals in IT and software development that help one another with answers to tough questions and share insights. Get the best answers to your questions from over 225,689 network members.

dev questions:
algorithms | asp | asp.net | c/c++ | coldfusion | c# | flash | html/css | java | javascript |
mobile dev | .net | perl | php | python | ruby | software dev | vb.net | visual basic | xml
it questions:
access | apache | careers | db2 | iis | macosx | mysql | networking | oracle | postgresql | sql server | unix | windows

About Bytes | Copyright 1995-2009 BYTES. All rights Reserved