Ja, das war ursprünglich auch der Plan. Da ich aber keine Ahnung hab, wie ich mir das mit den Flags vorstellen soll, habe ich das so neu interpretiert. Bin da ehrlich gesagt verwirrt...In Deinem vorletzen Beitrag klang das noch so als wenn Du den Job-Datensatz tatsächlich löschen wolltest und bei den Zeiten zu dem Job ein Flag setzen wolltest
Code: Alles auswählen
# ...
class Job(Base):
__tablename__ = 'job'
id = Column(INT, primary_key=True)
title = Column(TEXT, nullable=False, unique=True)
is_active = Column(BOOLEAN, nullable=False, default=True)
class TimeSlot(Base):
__tablename__ = 'time_slot'
id = Column(INT, primary_key=True)
job_id = Column(ForeignKey(Job.id), nullable=False)
start_time = Column(DATETIME, nullable=False)
job = relationship(Job)
@property
def is_active(self):
return self.job.is_active
# ...
job = Job(title='Nase bohren')
session.save(job)
slot = TimeSlot(job=job, start_time=datetime.datetime(2016, 12, 14, 12, 15))
session.save(job)
session.commit()
all_jobs = session.Query(Job).all()
active_jobs = session.Query(Job).filter_by(is_active=True).all()
today = datetime.date.today()
end_of_today = today + relativedelta(days=1, seconds=-1)
todays_slots = session.Query(TimeSlot).filter(
TimeSlot.start_time.between(today, end_of_today)
).all()Code: Alles auswählen
import sqlite3
class Database():
def __init__(self, filepath)
self.connection = sqlite3.connect(filepath)
self.create_tables()
def create_tables(self):
cursor = self.connection.cursor()
cursor.execute('''
create table if not exists
job
(
id integer not null
,bezeichnung text
)
;
create table if not exists
time_slot
(
ref_job integer not null
,von timestamp
,bis timestamp
)
;''')
cursor.execute('''
alter table job
add primary key (id)
;
alter table time_slot
add foreign key zeit_job (ref_job)
references (job)
on delete set null
alter table zeit
add primary key (ref_job)
;
''')
self.connection.commit()
def insert_job(self, title):
cursor = self.connection.cursor()
cursor.execute('''
insert into
job
values
(?)
''', (title, )
)
self.connection.commit()
def insert_time(self, begin, end, ref_job)
cursor = self.connection.cursor()
cursor.execute('''
insert into
time_slot
values
(?,?,?)
''', (ref_job, begin, end)
)
self.connection.commit()
def read_data(self, XXXXXX) Weiß ich nicht genau. Ich nehme an, es war ein Tipp für uns Anfänger: erstmal die Tabellen sauber erstellen, dann Contraints anlegen, dann nächste Tabelle. Bei sehr großen creates nehme ich an, dass auch der Ausbilder auf die Kurzschreibweise zurückgegriffen hätte. Er hat sie nämlich explizit erwähnt, allerdings stehen bei den besprochenen Änderungen an DB2 Systemen allenfalls einzelne Tabellen-Creates an, höchst selten mal mehr als zwei gleichzeitig. Die müssen aber passen.Was ist denn die Begründung dafür Primär- und Fremdschlüssel erst in einem zweiten Gang bekannt zu machen?
Ups, das ist der alte Name. Habe sie in time_slots umbenannt, muss das hier noch ändern...Wo ist die Deklaration der Tabelle `zeit`?
Das ist keine Regel aus der Ausbildung, sondern eine Überlegung von mir. Es gab ja den Hinweis, am besten über IDs abzufragen. Ich sehe das wie du, obwohl das Datum prinzipiell schon keyfähig wäre. Es sind ja Datetime Objekte, und da nur ein Job zu einer Zeit gespeichert werden kann, sollte es gehen. Trotzdem lieber über Fremdschlüssel zu Job, das finde ich sauberer.Warum soll man keine Abfragen auf Nicht-Schlüssel-Felder machen? Wenn das doch aber die Kriterien sind die den Benutzer interessieren? Komische Regel(‽)
Code: Alles auswählen
import sqlite3
class Database():
def __init__(self, filepath):
self.connection = sqlite3.connect(filepath)
self.create_tables()
def create_tables(self):
cursor = self.connection.cursor()
cursor.execute('''
create table if not exists
job
(
id integer primary key not null
,bezeichnung text
)
;''')
cursor.execute('''
create table if not exists
time_slot
(
ref_job integer primary key not null
,von timestamp
,bis timestamp
,foreign key(ref_job)
references job(id)
on delete cascade
)
;''')
self.connection.commit()
def insert_job(self, title):
cursor = self.connection.cursor()
cursor.execute('''
insert into
job(bezeichnung)
values
(?)
''', (title, )
)
self.connection.commit()
def update_job(self, term, job_id):
cursor = self.connection.cursor()
cursor.execute('''
update
job
set
bezeichnung = ?
where
id = ?
''', (term, job_id))
self.connection.commit()
def insert_time(self, begin, end, ref_job):
cursor = self.connection.cursor()
cursor.execute('''
insert into
time_slot
values
(?,?,?)
''', (ref_job, begin, end)
)
self.connection.commit()
def read_job(self, term):
cursor = self.connection.cursor()
job_id = cursor.execute('''
select
id
from
job
where
bezeichnung = ?
''', (term,))
job_id = job_id.fetchone()[0]
cursor.close()
return job_id
def read_data(self, begin, end):
cursor = self.connection.cursor()
jobs_done = cursor.execute('''
select
job.bezeichnung
from
job
,time_slot
where
time_slot.ref_job = job.id
and
time_slot.von = ?
and
time_slot.bis = ?
''', (begin, end))
jobs_done = jobs_done.fetchall()
cursor.close()
return jobs_done
def remove_job(self, job_id):
cursor = self.connection.cursor()
cursor.execute('''
delete from
job
where
id = ?
''', (job_id,))
self.connection.commit()
Erledigt. Stimmt, dann kann man die ID gleich benutzen, z.B. wenn man den Namen des neuen Jobs in der GUI anzeigen will.Deshalb sollte insert_job auch die neu erzeugte ID zurückgeben.
Einen Job soll es nur einmal geben, daher bietet sich der unique constraint an. Ist eingebaut.read_job hieße besser find_job_id und sollte noch prüfen, ob wirklich nur ein Job mit dieser Bezeichnung existiert. Soweit ich sehe ist die Spalte bezeichnung nicht unique
Korrekt - so, wie sie jetzt da steht, soll die Funktion zu viel leisten, was sie gar nicht kann. Ich brauche in Bezug auf die Tabelle Job drei Funktionen/selects, die irgendwie Daten auslesen:Warum heißt das Ergebnis jobs_done? Auch hier solltest Du mit job_ids arbeiten, so dass der Join gar nicht nötig ist. Willst Du nicht nach Jobs suchen, für die gilt von<=datum<=ende? Normalerweise weiß man ja nicht, wann ein Job angefangen hat und wann er beendet wurde?
Code: Alles auswählen
from functools import wraps
def commits(func)
@wraps(func)
def _d(self, *a, **k):
res = func(self, *a, **k)
self.connection.commit()
return res
return _d
...
class Foo(...):
@commits
def neuer_job(...)
Ich steh auf milde Meckereien. Deswegen bin ich hier__deets__ hat geschrieben: Wie immer milde Meckereien, bzw. Verbesserungsvorschlaege:
Danke fürs Feedback!
Du meinst also ein Modul bestehend lediglich aus einer Liste mit allen nötigen SQL Statements, die dann in den Python Funktionen nur mit Liste[Index] angesprochen werden? Klingt nice, aber wie ist das dann bei Parametern, die in das SQL reinmüssen? Deren Verwendung wird durch die Auslagerung in ein Modul ja eher erschwert, oder?Statt in der Methode ewig lange SQL-statements zu haben, wuerde ich eher eine Liste auf Modulebene anlegen, "CREATE_STATEMENTS", und ueber die rueberlaufen, und die dann abfeuern
Code: Alles auswählen
CREATE_TABLE_STATEMENTS = [
"""create table foo (
....
)""",
"""create table foo (
....
)""",
]
...
for statement in CREATE_TABLE_STATEMENTS:
cursor.execute(statement)