Das deutsche Python-Forum

Code: Alles auswählen

import Datenbank

db = Datenbank.Datenbank('testdatei.db')
db.testen()

Code: Alles auswählen

import sqlite3

class Datenbank:
    def __init__(self, datenbankname):
        self.datei = datenbankname
        self.connection = sqlite3.connect(datenbankname)
    
    def testen(self):
        self.cursor = self.connection.cursor()
        self.sql_command = """
        CREATE TABLE employee ( 
        staff_number INTEGER PRIMARY KEY, 
        fname VARCHAR(20), 
        lname VARCHAR(30), 
        gender CHAR(1), 
        joining DATE,
        birth_date DATE);"""

        self.cursor.execute(self.sql_command)

        self.sql_command = """INSERT INTO employee (staff_number, fname, lname, gender, birth_date)
        VALUES (NULL, "William", "Shakespeare", "m", "1961-10-25");"""
        self.cursor.execute(self.sql_command)


        self.sql_command = """INSERT INTO employee (staff_number, fname, lname, gender, birth_date)
        VALUES (NULL, "Frank", "Schiller", "m", "1955-08-17");"""
        self.cursor.execute(self.sql_command)

        # never forget this, if you want the changes to be saved:
        self.connection.commit()

        self.connection.close()

Code: Alles auswählen

import sqlite3
from contextlib import closing
from sqlite3 import Date


class Database(object):

    def __init__(self, filename):
        self.connection = sqlite3.connect(filename)
    
    def __enter__(self):
        return self

    def __exit__(self, *_args):
        self.close()
    
    def close(self):
        self.connection.close()

    def test(self):
        with closing(self.connection.cursor()) as cursor:
            try:
                cursor.execute(
                    'CREATE TABLE employee ('
                    ' id INTEGER PRIMARY KEY,'
                    ' firstname VARCHAR(200) NOT NULL,'
                    ' lastname VARCHAR(200) NOT NULL,'
                    " gender CHAR(1) NOT NULL DEFAULT '?'"
                        " CHECK (gender IN ('m', 'f', '?')),"
                    ' joined DATE NOT NULL DEFAULT CURRENT_DATE,'
                    ' birth_date DATE NOT NULL'
                    ');'
                )
                cursor.executemany(
                    'INSERT INTO employee (firstname, lastname, gender,'
                        ' birth_date)'
                    ' VALUES (?, ?, ?, ?);',
                    [
                        ['William', 'Shakespeare', 'm', Date(1961, 10, 25)],
                        ['Frank', 'Schiller', 'm', Date(1955, 8, 17)],
                    ]
                )
                self.connection.commit()
            except:
                self.connection.rollback()
                raise


def main():
    with Database('test.db') as database:
        database.test()

 
if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf8
from __future__ import absolute_import, division, print_function
from datetime import date as Date

from dateutil.relativedelta import relativedelta
from sqlalchemy import CHAR, Column, create_engine, DATE, INTEGER, VARCHAR
from sqlalchemy.orm import Session
from sqlalchemy.ext.declarative import declarative_base


Base = declarative_base()


class Employee(Base):

    __tablename__ = 'employee'

    id = Column(INTEGER, primary_key=True)
    firstname = Column(VARCHAR(200), nullable=False)
    lastname = Column(VARCHAR(200), nullable=False)
    gender = Column(CHAR(1), nullable=False, default='?')
    joined = Column(DATE, nullable=False, default=Date.today)
    birth_date = Column(DATE, nullable=False)

    @property
    def age(self):
        return relativedelta(Date.today(), self.birth_date).years


def print_employees(employees):
    for employee in employees:
        print(
            '  {0.firstname} {0.lastname} ({0.age}),'
            ' geb. {0.birth_date:%d.%m.%Y}'.format(employee)
        )
    print()


def main():
    # 
    # Datenbank-Engine erstellen: Hier kann man sehr einfach die URL austauschen
    # und damit ein andere DBMS wählen ohne das man am Rest des Beispiels etwas
    # ändern muss.
    # 
    engine = create_engine('sqlite:///test.db')
    # 
    # Alle Tabellen für von `Base` abgeleitete Klassen erstellen sofern die
    # Tabelle nicht bereits existiert:
    # 
    Base.metadata.create_all(engine)
    
    session = Session(engine)
    # 
    # Ein paar Daten eintragen:
    # 
    for firstname, lastname, gender, birth_date in [
        ('William', 'Shakespeare', 'm', Date(1961, 10, 25)),
        ('Frank', 'Schiller', 'm', Date(1955, 8, 17)),
        ('Jane', 'Wall', 'f', Date(1989, 3, 14)),
    ]:
        session.add(
            Employee(
                firstname=firstname,
                lastname=lastname,
                gender=gender,
                birth_date=birth_date,
            )
        )
    session.commit()
    # 
    # Jane Wall wird Profiwrestlerin und ändert ihren Nachnamen in „Thunder“:
    # 
    jane = (
        session.query(Employee)
            .filter_by(firstname='Jane', lastname='Wall')
            .one()  # Wenn es mehr als einen Datensatz gibt auf den das zutrifft
                    # dann führt `one()` zu einer Ausnahme!
    )
    jane.lastname = 'Thunder'
    session.commit()

    # 
    # Ein paar Abfragen:
    # 
    employee_query = session.query(Employee)

    print('Alle Datensätze (nach Nachname sortiert):')
    print_employees(employee_query.order_by(Employee.lastname))

    print('Nur männliche Angestellte:')
    print_employees(employee_query.filter_by(gender='m'))

    print('Alle ab 1960 geborenen:')
    print_employees(
        employee_query.filter(Employee.birth_date >= Date(1960, 1, 1))
    )

    # 
    # Tabelle(n) wieder entfernen (sofern sie vorhanden sind):
    # 
    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    main()

Code: Alles auswählen

Alle Datensätze (nach Nachname sortiert):
  Frank Schiller (60), geb. 17.08.1955
  William Shakespeare (53), geb. 25.10.1961
  Jane Thunder (26), geb. 14.03.1989

Nur männliche Angestellte:
  William Shakespeare (53), geb. 25.10.1961
  Frank Schiller (60), geb. 17.08.1955

Alle ab 1960 geborenen:
  William Shakespeare (53), geb. 25.10.1961
  Jane Thunder (26), geb. 14.03.1989