Das deutsche Python-Forum

kaj@Birger[kajtajm]$ ktclasses.py
X connection to /tmp/launch-8TKCAP/:0 broken (explicit kill or server shutdown).
X connection to /tmp/launch-8TKCAP/:0 broken (explicit kill or server shutdown).
./ktclasses.py: line 6: class: command not found
./ktclasses.py: line 7: syntax error near unexpected token `('
./ktclasses.py: line 7: ` db = MySQLdb.connect(db="kajtajm",read_default_file="~/.my.cnf")'

kaj@Birger[kajtajm]$ python
Python 2.5.1 (r251:54863, Feb 6 2009, 19:02:12)
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> # Classes for kajtajm
...
>>> import sys
>>> import MySQLdb
>>>
>>> class KtDbRow:
... db = MySQLdb.connect(db="kajtajm",read_default_file="~/.my.cnf")
... # myKtRow = KtRow("2010-01-01",1000,1015,"Python","Some long text")
...blabla die ganzen Zeilen...
>>> myKtDbRow = KtDbRow("2010-01-25",1100,1015,"Python","Some long text")
>>> print myKtDbRow.val()
2010-01-25 1100-1015 Python -0.75 (Some) Some long text
>>> print myKtDbRow.shortval()
1100-1015 Python -0.75 (Some) Some long text
>>> print myKtDbRow.wherestring()
WHERE kajdate="2010-01-25" AND timefrom=1100
>>> print myKtDbRow.insertstring()
INSERT INTO kajtimerow (kajdate, timefrom, timeto, project, kajtext, hours, keyword) VALUES ("2010-01-25",1100,1015,"Python","Some long text",-0.75,"Some")
>>> print myKtDbRow.updatestring()
UPDATE kajtimerow SET timeto=1015, project="Python", kajtext="Some long text", hours=-0.75, keyword="Some" WHERE kajdate="2010-01-25" AND timefrom=1100
>>> print myKtDbRow.deletestring()
DELETE from kajtimerow WHERE kajdate="2010-01-25" AND timefrom=1100
>>> print myKtDbRow.exists()
(datetime.date(2010, 1, 25), 1100, 1115, 'kajtajm', 'ktrpt F\xc3\xb6rb\xc3\xa4ttringar (urval, rubriker', Decimal("0.25"), 'ktrpt')
False
>>>

# Classes for kajtajm

import sys
import MySQLdb

class KtDbRow:
    db = MySQLdb.connect(db="kajtajm",read_default_file="~/.my.cnf")
    # Wann wird je die obige Zeile ausgeführt?
    # myKtRow = KtRow("2010-01-01",1000,1015,"Python","Some long text")
    def __init__(self, kajdate, timefrom, timeto, project, kajtext):
        self.kajdate = str(kajdate) # in MySQL format i.e. 2001-01-01
        self.timefrom = int(timefrom)
        self.timeto = int(timeto)
        self.project = project # 10 chars
        self.kajtext = kajtext # 50 chars
        self.hours = (60*(timeto/100-timefrom/100) + timeto%100 - timefrom%100)/60.0
        self.keyword = kajtext.split()[0][0:10] # First 10 chars of first word in kajtext
    def info(self):
        return (self)
    #
    # Contents in user readable string form
    def shortval(self):
        return str(self.timefrom) + "-" + str(self.timeto) + " " + self.project \
            + " " + str(self.hours) + " (" + self.keyword + ") " + self.kajtext
    def val(self):
        return self.kajdate + " " + self.shortval()
    #
    # SQL string representations
    def wherestring(self):
        return 'WHERE kajdate="' + self.kajdate + '" AND timefrom=' + str(self.timefrom)
    def insertstring(self):
        return "INSERT INTO kajtimerow (kajdate, timefrom, timeto, project, " + \
            'kajtext, hours, keyword) VALUES ("'  + self.kajdate + '",' + str(self.timefrom) + \
            ',' + str(self.timeto) + ',"' + self.project + '","' + self.kajtext + '",' + \
            str(self.hours) + ',"' + self.keyword + '")'
    def updatestring(self):
        return "UPDATE kajtimerow SET timeto=" + str(self.timeto)+ ', project="' \
            + self.project + '", kajtext="' + self.kajtext + '", hours=' + \
            str(self.hours) + ', keyword="' + self.keyword + '" ' + self.wherestring()
    def deletestring(self):
        return "DELETE from kajtimerow " + self.wherestring()
    #
    # Database communication
    def opendb(self):
      # Check the MySQLdb module is available, if not error and exit
      try:
        import MySQLdb
      except ImportError:
        print "\nktopendb.py error: MySQLdb module required for interactive usage\n"
        sys.exit(0)
      # Open the connection to the database
      try:
        return MySQLdb.connect(db="kajtajm",read_default_file="~/.my.cnf")
      # If there is an exception, print the error and exit
      except MySQLdb.Error, e:
        print "ktopendb.py: Couldn't open kajtajm database"
        print "Error %d: %s" % (e.args[0], e.args[1])
        sys.exit (1)
    def exists(self):
        db = self.opendb()
        c = db.cursor()
        c.execute("SELECT * FROM kajtajmrow " + self.wherestring())
        row = c.fetchone()
        print row
        return row[0]==1
    def insert(self):
        return true
    def update(self):
        return true
    def delete(self):
        return true

myKtDbRow = KtDbRow("2010-01-25",1100,1015,"Python","Some long text")
print myKtDbRow.val()
print myKtDbRow.shortval()
print myKtDbRow.wherestring()
print myKtDbRow.insertstring()
print myKtDbRow.updatestring()
print myKtDbRow.deletestring()
print myKtDbRow.exists()

lunar hat geschrieben:Muss man denn unter Mac OS X keinen Shebang angeben?

lunar hat geschrieben:Was denn Quelltext angeht:
- Prepared Statements nutzen statt SQL-Ausdrücke mit Zeichenkettenverkettung zusammenzusetzen

lunar hat geschrieben:- Eine Datenbankverbindung auf Klassenebene ist eine schlechte Idee. Zum einen lässt sich die Klasse dann nur aus einem Thread heraus nutzen, zum anderen kann die Datenbank während der Lebenszeit der Klasse nicht geschlossen werden.

lunar hat geschrieben:- sys.exit(1) in einer Klasse ist nicht sehr nett gegenüber dem Benutzer dieser Klasse

lunar hat geschrieben: Davon abgesehen: ORMs gibt es bereits in großer Anzahl und vielen Varianten. Zur Übung ist nichts gegen einen eigenen Versuch zu sagen, in produktiver Umgebung aber ist man mit SQLAlchemy, Storm u.ä. eigentlich besser bedient.

lunar hat geschrieben:Der Vorschlag, Prepared Statements zu nutzen, hatte weniger mit Effizienz zu tun, als vielmehr mit Sicherheit und Robustheit. Ohne Prepared Statements musst Du die Eingabeparameter validieren und maskieren, um SQL-Injections und Syntaxfehlern (falls SQL-Sonderzeichen oder Schlüsselwörter in den Parametern enthalten sind) vorzubeugen. Prepared Statements nehmen Dir diese Arbeit ab. Zudem sehen sie im Quelltext übersichtlicher aus als Zeichenketten-Konkatenation.

lunar hat geschrieben:Für die Verwaltung der Datenbankverbindung würde ich bei diesem einfachen Beispiel das Kontextmanager-Protokoll implementieren. In __enter__ wird die Verbindung geöffnet, in __exit__ geschlossen. Innerhalb des Blocks kann man dann Datenbankoperationen ausführen.

lunar hat geschrieben:Falls beim Öffnen Fehler auftreten, so würde ich sie gar nicht behandeln, denn im Allgemeinen gilt, dass man Ausnahmen nach oben weiterreichen sollte, wenn man sie an einer Stelle nicht sinnvoll behandeln kann. Ausnahmen sind als Fehlerindikator stark genug, da sie die Ausführung an der aktuellen Stelle abbrechen. sys.exit() dagegen ist zu stark, denn es bricht den Prozess ab (streng genommen kann man sys.exit() auch abfangen, aber das ist nicht Sinn der Übung).

DasIch hat geschrieben:Du solltest dir auch klar machen was du genau repräsentieren willst. Schaue dir mal folgende Fragen und versuche sie zu beantworten ohne auf deinen Code zu schauen oder an ihn zu Denken.

Ist die Zahl von Spalten in einer Zeile veränderbar oder nicht? Sind die Elemente in einer Zeile sortiert oder haben sie eine Ordnung und welchen Einfluss hat dies?

Was kann man mit einer Zeile machen? Kann man sie verändern und wenn ja wie?

Welche Tätigkeiten stehen im Zusammenhang mit einer Zeile in der Datenbank? In welchen davon agiert die Zeile selbst, in welchen agieren andere mit der Zeile und wie?

Ist die Bezeichnung Zeile und/oder seine Repräsentation in der Datenbank wichtig/relevant für die API bzw. lässt sich dieser Umstand akzeptabel abstrahieren?

Sind die Fragen beantwortet betrachte deinen Code, unter Berücksichtungen der Fragen bzw. den Antworten zu diesen. Entspricht deine Implementation deiner eigenen Vorstellung?

Wenn dir klar ist was eine Zeile ist, was sie macht und womit, sollte der Code kein Problem mehr sein.

jens hat geschrieben:[wiki]Parametrisierte SQL-Queries[/wiki]

#!/usr/bin/env python 
# -*- coding: latin-1 -*-
# 
# ktreplace: Replace one project with another in all of kajtajm

import sys 
from ktopendb import db
from datetime import date

print "ktreplace " + date.today().strftime("%a %d.%m.%Y")

paramcount = len(sys.argv) - 1

if paramcount < 2:
  print "Syntax: ktreplace <fromproject> <toproject> [do]"
  sys.exit(1)
paramfromproject = sys.argv[1]
paramtoproject = sys.argv[2]

if paramcount >= 3:
  paramdo = sys.argv[3] == "do"
  will = "will"
else:
  paramdo = False
  will = "would"

c=db.cursor()
c.execute("SELECT count(*) FROM kajtajmrow WHERE project=""%s""", (paramfromproject))
selectresult = c.fetchone()
fromcount = selectresult[0]

c.execute("SELECT count(*) FROM kajtajmrow WHERE project=""%s""", (paramtoproject))
selectresult = c.fetchone()
tocount = selectresult[0]

print "%d row(s) with project %s %s be converted to project %s, which until now has %d row(s)" % \
  (fromcount, paramfromproject, will, paramtoproject, tocount)

if paramdo:
  c=db.cursor()
  c.execute("UPDATE kajtajmrow SET project=""%s"" WHERE project=""%s""", (paramtoproject, paramfromproject))

db.commit()
# Close the connection once finished 
db.close ()

kajarno hat geschrieben:

Code: Alles auswählen

...
c.execute("SELECT count(*) FROM kajtajmrow WHERE project=""%s""", (paramfromproject))
...
c.execute("SELECT count(*) FROM kajtajmrow WHERE project=""%s""", (paramtoproject))
...

...
c.execute("SELECT count(*) FROM kajtajmrow WHERE project=%s", (paramfromproject))
...
c.execute("SELECT count(*) FROM kajtajmrow WHERE project=%s", (paramtoproject))
...