Groschengedanken zu Software

use test

/*
	Warenkorb-Analyse
	=================
	
	Bei youtube fand ich ein Science-Slam-Video zu Wirtschafts-Informatik,
	bei dem das Stichwort "Warenkorbanalyse" fiel. Interessante Sache 
	das, also habe ich das Beispiel aus dem Video in MySQL nachgebaut.
*/

create table einkauf
(
	e_id int,
	prod_id int
);

create table produkt
(
	prod_id int,
	name varchar (255)
);

insert into produkt ( prod_id, name ) values ( 1 , 'Cola');
insert into produkt ( prod_id, name ) values ( 2 , 'Milch');
insert into produkt ( prod_id, name ) values ( 3 , 'Bier');
insert into produkt ( prod_id, name ) values ( 4 , 'Pizza');
insert into produkt ( prod_id, name ) values ( 5 , 'Pampers');

insert into einkauf ( e_id, prod_id ) values ( 1, 1 );
insert into einkauf ( e_id, prod_id ) values ( 1, 2 );
insert into einkauf ( e_id, prod_id ) values ( 1, 4 );
insert into einkauf ( e_id, prod_id ) values ( 2, 2 );
insert into einkauf ( e_id, prod_id ) values ( 2, 5 );
insert into einkauf ( e_id, prod_id ) values ( 3, 1 );
insert into einkauf ( e_id, prod_id ) values ( 3, 4 );
insert into einkauf ( e_id, prod_id ) values ( 4, 2 );
insert into einkauf ( e_id, prod_id ) values ( 4, 3 );
insert into einkauf ( e_id, prod_id ) values ( 5, 1 );
insert into einkauf ( e_id, prod_id ) values ( 5, 3 );

SELECT * FROM produkt;
SELECT * FROM einkauf;

/*
	Alle Produkt-Paare aus den Einkäufen herausfinden, d.h.
	für jeden Einkauf jedes Produkt mit allen anderen
	Produkten dieses Einkaufs kombinieren.
	NB: Wenn ein Produkt innerhalb eines Einkaufs mehrfach
	vorkommt, dann muss das vorher gruppiert werden. Ich gehe
	hier oBdA davon aus, dass jedes Produkt nur einmal in jedem
	Einkauf vorkommt.
*/

SELECT ek1.e_id, ek1.prod_id, ek2.prod_id
FROM einkauf ek1, einkauf ek2
where ek1.e_id = ek2.e_id;

/*
	An dieser Stelle spielt die Einkaufsnummer keine Rolle.
	Hauptsache, ich kenne alle Paarungen.
	Das sind die Paarungen, die vorkommen.
	Was ist mit denen, die nicht vorkommen?
*/

SELECT ek1.prod_id, ek2.prod_id
FROM einkauf ek1, einkauf ek2
where ek1.e_id = ek2.e_id;

/*
	So gruppieren, dass ich sehe, welches Paar wie oft
	vorkommt.
	Die Zeilen, bei denen ek1.prod_id = ek2.prod_id ist,
	geben an, wie oft das Produkt mit der ek1.prod_id
	insgesamt gekauft wurde. 
*/

SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl
FROM einkauf ekl, einkauf ekr
where ekl.e_id = ekr.e_id
group by prodA, prodB;

/*
	Welche Kombinationen fehlen für das jeweilige Produkt?
	Nun, vergleiche die obige Tabelle mit dem kartesischen Produkt
	der Waren.
*/

SELECT * 
FROM (
	SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl
	FROM einkauf ekl, einkauf ekr
	where ekl.e_id = ekr.e_id
	group by prodA, prodB
) tupels 
right outer join 
(
	select prl.prod_id as prodR, prr.prod_id as prodL
	from produkt prl, produkt prr
) alleWarenTupel
on tupels.prodA = alleWarenTupel.prodR
and tupels.prodB = alleWarenTupel.prodL;

/*
	Von obiger Tabelle zeige ich prodA und prodB nicht an,
	denn prodR und prodL sind bedeutungsgleich. Wichtig ist,
	dass ich für die jeweilige Paarung die Anzahl kenne.
*/

SELECT alleWarenTupel.prodL, alleWarenTupel.prodR, tupels.anzahl
FROM (
	SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl
	FROM einkauf ekl, einkauf ekr
	where ekl.e_id = ekr.e_id
	group by prodA, prodB
) tupels 
right outer join 
(
	select prl.prod_id as prodR, prr.prod_id as prodL
	from produkt prl, produkt prr
) alleWarenTupel
on tupels.prodA = alleWarenTupel.prodR
and tupels.prodB = alleWarenTupel.prodL;

/*
	Wie bekomme ich eine hübsche Tabelle?
	Ich hätte gerne die Spalte "anzahl" in Fünfer-Pakete aufgeteilt, so
	dass die ersten fünf Werte hintereinander stehen, in der zweiten
	Zeile die zweiten fünf Werte usw.
	Für MSSQL scheint es unkompliziert, siehe
	http://www.brighthub.com/internet/web-development/articles/91895.aspx
	Für MySQL ist es umständlich(er)
	http://www.onlamp.com/pub/a/onlamp/2003/12/04/crosstabs.html

	Schließlich ein Dank an
	http://en.wikibooks.org/wiki/MySQL/Pivot_table

	Wermutstropfen: Die Spaltennamen sind "hardcodiert". Bei großem
	Produktumfang wird das eine Qual :/, also doch besser in eine 
	Tabellenkalkulation bringen.
*/

select prodL, ProdName,
sum(anzahl*(1-abs(sign(prodR-1)))) as 'Cola',
sum(anzahl*(1-abs(sign(prodR-2)))) as 'Milch',
sum(anzahl*(1-abs(sign(prodR-3)))) as 'Bier',
sum(anzahl*(1-abs(sign(prodR-4)))) as 'Pizza',
sum(anzahl*(1-abs(sign(prodR-5)))) as 'Pampers'
from (
	SELECT alleWarenTupel.prodL, alleWarenTupel.ProdName, alleWarenTupel.prodR, tupels.anzahl
		FROM (
		SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl
		FROM einkauf ekl, einkauf ekr
		where ekl.e_id = ekr.e_id
		group by prodA, prodB
	) tupels 
	right outer join 
	(
		select prl.prod_id as prodR, prr.prod_id as prodL, prr.name as ProdName
		from produkt prl, produkt prr
	) alleWarenTupel
	on tupels.prodA = alleWarenTupel.prodR
	and tupels.prodB = alleWarenTupel.prodL
) pivot
group by prodL, ProdName;

select ProdName, Cola, Milch, Bier, Pizza, Pampers
from 
(
	select prodL, ProdName,
	sum(anzahl*(1-abs(sign(prodR-1)))) as 'Cola',
	sum(anzahl*(1-abs(sign(prodR-2)))) as 'Milch',
	sum(anzahl*(1-abs(sign(prodR-3)))) as 'Bier',
	sum(anzahl*(1-abs(sign(prodR-4)))) as 'Pizza',
	sum(anzahl*(1-abs(sign(prodR-5)))) as 'Pampers'
	from (
		SELECT alleWarenTupel.prodL, alleWarenTupel.ProdName, alleWarenTupel.prodR, tupels.anzahl
			FROM (
			SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl
			FROM einkauf ekl, einkauf ekr
			where ekl.e_id = ekr.e_id
			group by prodA, prodB
		) tupels 
		right outer join 
		(
			select prl.prod_id as prodR, prr.prod_id as prodL, prr.name as ProdName
			from produkt prl, produkt prr
		) alleWarenTupel
		on tupels.prodA = alleWarenTupel.prodR
		and tupels.prodB = alleWarenTupel.prodL
	) pivot
	group by prodL, ProdName
) nice;

-- Aufräumen;
--
drop table einkauf;
drop table produkt;

-- Ende.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

use test

Warenkorb-Analyse

=================

Bei youtube fand ich ein Science-Slam-Video zu Wirtschafts-Informatik,

bei dem das Stichwort "Warenkorbanalyse" fiel. Interessante Sache

das, also habe ich das Beispiel aus dem Video in MySQL nachgebaut.

create table einkauf

(

e_id int,

prod_id int

);

create table produkt

(

prod_id int,

name varchar (255)

);

insert into produkt ( prod_id, name ) values ( 1 , 'Cola');

insert into produkt ( prod_id, name ) values ( 2 , 'Milch');

insert into produkt ( prod_id, name ) values ( 3 , 'Bier');

insert into produkt ( prod_id, name ) values ( 4 , 'Pizza');

insert into produkt ( prod_id, name ) values ( 5 , 'Pampers');

insert into einkauf ( e_id, prod_id ) values ( 1, 1 );

insert into einkauf ( e_id, prod_id ) values ( 1, 2 );

insert into einkauf ( e_id, prod_id ) values ( 1, 4 );

insert into einkauf ( e_id, prod_id ) values ( 2, 2 );

insert into einkauf ( e_id, prod_id ) values ( 2, 5 );

insert into einkauf ( e_id, prod_id ) values ( 3, 1 );

insert into einkauf ( e_id, prod_id ) values ( 3, 4 );

insert into einkauf ( e_id, prod_id ) values ( 4, 2 );

insert into einkauf ( e_id, prod_id ) values ( 4, 3 );

insert into einkauf ( e_id, prod_id ) values ( 5, 1 );

insert into einkauf ( e_id, prod_id ) values ( 5, 3 );

SELECT * FROM produkt;

SELECT * FROM einkauf;

Alle Produkt-Paare aus den Einkäufen herausfinden, d.h.

für jeden Einkauf jedes Produkt mit allen anderen

Produkten dieses Einkaufs kombinieren.

NB: Wenn ein Produkt innerhalb eines Einkaufs mehrfach

vorkommt, dann muss das vorher gruppiert werden. Ich gehe

hier oBdA davon aus, dass jedes Produkt nur einmal in jedem

Einkauf vorkommt.

SELECT ek1.e_id, ek1.prod_id, ek2.prod_id

FROM einkauf ek1, einkauf ek2

where ek1.e_id = ek2.e_id;

An dieser Stelle spielt die Einkaufsnummer keine Rolle.

Hauptsache, ich kenne alle Paarungen.

Das sind die Paarungen, die vorkommen.

Was ist mit denen, die nicht vorkommen?

SELECT ek1.prod_id, ek2.prod_id

FROM einkauf ek1, einkauf ek2

where ek1.e_id = ek2.e_id;

So gruppieren, dass ich sehe, welches Paar wie oft

vorkommt.

Die Zeilen, bei denen ek1.prod_id = ek2.prod_id ist,

geben an, wie oft das Produkt mit der ek1.prod_id

insgesamt gekauft wurde.

SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl

FROM einkauf ekl, einkauf ekr

where ekl.e_id = ekr.e_id

group by prodA, prodB;

Welche Kombinationen fehlen für das jeweilige Produkt?

Nun, vergleiche die obige Tabelle mit dem kartesischen Produkt

der Waren.

SELECT *

FROM (

SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl

FROM einkauf ekl, einkauf ekr

where ekl.e_id = ekr.e_id

group by prodA, prodB

) tupels

right outer join

(

select prl.prod_id as prodR, prr.prod_id as prodL

from produkt prl, produkt prr

) alleWarenTupel

on tupels.prodA = alleWarenTupel.prodR

and tupels.prodB = alleWarenTupel.prodL;

Von obiger Tabelle zeige ich prodA und prodB nicht an,

denn prodR und prodL sind bedeutungsgleich. Wichtig ist,

dass ich für die jeweilige Paarung die Anzahl kenne.

SELECT alleWarenTupel.prodL, alleWarenTupel.prodR, tupels.anzahl

FROM (

SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl

FROM einkauf ekl, einkauf ekr

where ekl.e_id = ekr.e_id

group by prodA, prodB

) tupels

right outer join

(

select prl.prod_id as prodR, prr.prod_id as prodL

from produkt prl, produkt prr

) alleWarenTupel

on tupels.prodA = alleWarenTupel.prodR

and tupels.prodB = alleWarenTupel.prodL;

Wie bekomme ich eine hübsche Tabelle?

Ich hätte gerne die Spalte "anzahl" in Fünfer-Pakete aufgeteilt, so

dass die ersten fünf Werte hintereinander stehen, in der zweiten

Zeile die zweiten fünf Werte usw.

Für MSSQL scheint es unkompliziert, siehe

http://www.brighthub.com/internet/web-development/articles/91895.aspx

Für MySQL ist es umständlich(er)

http://www.onlamp.com/pub/a/onlamp/2003/12/04/crosstabs.html

Schließlich ein Dank an

http://en.wikibooks.org/wiki/MySQL/Pivot_table

Wermutstropfen: Die Spaltennamen sind "hardcodiert". Bei großem

Produktumfang wird das eine Qual :/, also doch besser in eine

Tabellenkalkulation bringen.

select prodL, ProdName,

sum(anzahl*(1-abs(sign(prodR-1)))) as 'Cola',

sum(anzahl*(1-abs(sign(prodR-2)))) as 'Milch',

sum(anzahl*(1-abs(sign(prodR-3)))) as 'Bier',

sum(anzahl*(1-abs(sign(prodR-4)))) as 'Pizza',

sum(anzahl*(1-abs(sign(prodR-5)))) as 'Pampers'

from (

SELECT alleWarenTupel.prodL, alleWarenTupel.ProdName, alleWarenTupel.prodR, tupels.anzahl

FROM (

SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl

FROM einkauf ekl, einkauf ekr

where ekl.e_id = ekr.e_id

group by prodA, prodB

) tupels

right outer join

(

select prl.prod_id as prodR, prr.prod_id as prodL, prr.name as ProdName

from produkt prl, produkt prr

) alleWarenTupel

on tupels.prodA = alleWarenTupel.prodR

and tupels.prodB = alleWarenTupel.prodL

) pivot

group by prodL, ProdName;

select ProdName, Cola, Milch, Bier, Pizza, Pampers

from

(

select prodL, ProdName,

sum(anzahl*(1-abs(sign(prodR-1)))) as 'Cola',

sum(anzahl*(1-abs(sign(prodR-2)))) as 'Milch',

sum(anzahl*(1-abs(sign(prodR-3)))) as 'Bier',

sum(anzahl*(1-abs(sign(prodR-4)))) as 'Pizza',

sum(anzahl*(1-abs(sign(prodR-5)))) as 'Pampers'

from (

SELECT alleWarenTupel.prodL, alleWarenTupel.ProdName, alleWarenTupel.prodR, tupels.anzahl

FROM (

SELECT ekl.prod_id as prodA, ekr.prod_id as prodB, count(ekl.prod_id) as anzahl

FROM einkauf ekl, einkauf ekr

where ekl.e_id = ekr.e_id

group by prodA, prodB

) tupels

right outer join

(

select prl.prod_id as prodR, prr.prod_id as prodL, prr.name as ProdName

from produkt prl, produkt prr

) alleWarenTupel

on tupels.prodA = alleWarenTupel.prodR

and tupels.prodB = alleWarenTupel.prodL

) pivot

group by prodL, ProdName

) nice;

-- Aufräumen;

drop table einkauf;

drop table produkt;

-- Ende.

Publiziert am 13. Oktober 2013 von matthias | Kommentare deaktiviert

Krüger, Guido: Handbuch der Java-Programmierung

Publiziert am 9. Oktober 2013 von matthias

Krüger, Guido: Handbuch der Java-Programmierung. 3. Auflage, München 2002.

Das Handbuch der Java-Programmierung gehört zum besten, das ich über Programmierung im allgemeinen und Java im besonderen gelesen habe. Kein Buch kann alles erklären und den wenigsten gelingt es, ein Thema erschöpfend darzustellen. Aber diese 1200-und-mehr Seiten sind klar und deutlich geschrieben. Dem geistig regen Leser wird der Horizont erweitert und es inspiriert zu neuen Fragen – aber “der Krüger” stellt einen nie vor Rätsel.

Auf knapp 500 Seiten präsentiert Krüger den Kern der Sprache “Java”. Didaktisch klug plaziert er das Kapitel über Objektorientierte Programmierung (OOP) nach den syntaktischen Grundlagen und vor den “weiterführenden Spracheigenschaften”, die das Wissen um OOP voraussetzen. Darauf folgen fast 400 Seiten über Grafikprogrammierung, das Thema “Applets” wird danach kurz behandelt. Das Ende des Hauptteils beleuchtet “Spezielle APIs” – beispielsweise jdbc, Sockets und Cryptographie.

Die Java-Themen, die Krüger behandelt, behandelt er detailiert. Die Beispiele sind gehaltvoll, prägnant, in sich abgeschlossen und verständlich. Krüger zeigt Zusammenhänge, ist sachlich, aber nie trocken, nie langweilig. Das Buch ist hervorragend für die Ausbildung geeignet – habe es an vier Kandidaten erprobt. Dazu habe ich einige Kapitel ausgewählt, deren Themen man m.E. als Programmier- und Java-Anfänger beigebracht bekommen muss. Anschließend einige Inhalte, anhand derer man exemplarische zeigen kann, wie java “tickt” und die in der täglichen Praxis im Ausbildungsbetrieb gebraucht werden: Kapitel 1, 2.2, 2.3, 3.2, 4, 5, 6,7, 8, 9.1, 11, 12, 13, 18, 20, 21, 42. Kapitel 50 bei Bedarf. Das ist der Lehrplan für’s erste Jahr, immer gepaart mit den dortigen kleinen Programmier-Aufgaben.

Der Teil über Objektorientierte Programmierung gehört zu den besten Texten, die ich zu diesem Thema kenne und die für ein breites Publikum geschrieben sind. Wer diesen Teil verstanden hat und weiss, wie die java-api-doc zu lesen ist, den bringt nichts mehr aus der Ruhe. Der Index des hjp ist hervorragend, auch nach jahrelanger Nutzung habe ich keine Einträge hinzugefügt – und das kommt leider nur selten vor.

Man sieht auf www.javabuch.de, dass fleissig an dem Buch gearbeitet wird. Ich habe mir seinerzeit die 3. Auflage gekauft und schaue auch heute noch immer wieder ‘rein. Ich empfehle es jedem ernsthaften Java-Programmierer zur Anschaffung.

[Reflexion]

Das obige ist eine mächtige Lobhudelei. Unangebrachte Lobhudelei kommt im Web oft vor. Ich kenne Guido Krüger nicht, bekomme keinen Cent für diesen Lobgesang und denke, dass er dem Buch gerecht wird.

Veröffentlicht unter Bibliographie | Kommentare deaktiviert

/*
	Nummeriere die Datensätze
	*************************

	Gegeben sei eine Tabelle aysx mit einem Primary Key. 
        Die Werte für den PK müssen nicht fortlaufend sein. 

        Aufgabe: Nummeriere die Datensätze 
	vom kleinsten bis zum größsten PK-Wert.

	Das folgende MySQL-Script zeigt exemplarisch, wie 
        das machbar ist. Bedenke, dass die Bestimmung des 
        Rangs (gidf) nicht auf eine "echte" Tabelle beschränkt 
        ist, sondern auch mit einem View und dem Ergebnis
	einer Abfrage durchgeführt werden kann.

	Beispieltext: aysx Matthias Kopp 2013
*/

create table aysx ( 
	id int PRIMARY KEY, 
	remark varchar ( 64 ));

/*
	Tabelle mit Beispieldaten füllen.
*/

insert into aysx ( id, remark ) values ( 1,	'Eins' );
insert into aysx ( id, remark ) values ( 512,	'FiveOneTwo' );
insert into aysx ( id, remark ) values ( 21,	'Antv' );
insert into aysx ( id, remark ) values ( 42,	'Antwort' );
insert into aysx ( id, remark ) values ( 23,	'whatever' );

/*
	Wesentlich ist der self-join. Der PK-Constraint garantiert,
	dass jede aysx.id nur einmal vorkommt. Eine id ist immer
	gleich ihrer selbst und alle anderen sind entweder größer
	oder kleiner. Die where-Bedingung sucht diejenigen Datensätze
	zusammen, die kleiner-gleich einer id sind - und das für
	alle ids. Schließlich wird für jede id eine Gruppe gebildet
	und die Anzahl der Elemente in der Gruppe ist eben der Rang.
*/

select count(*) as rang, t2.id
from aysx t1, aysx t2
where t1.id &lt;= t2.id
group by t2.id;

/*
	Ohne Gruppierung und Zählen - die "expandierte" Form.
	Hier kann man nachvollziehen, welche Elemente vorhanden sind.
	Zähle und gruppiere selbst!
*/

select t1.id, t2.id
from aysx t1, aysx t2
where t1.id &lt;= t2.id
order by t2.id

/* Auräumen. */
drop table aysx;

Nummeriere die Datensätze

*************************

Gegeben sei eine Tabelle aysx mit einem Primary Key.

Die Werte für den PK müssen nicht fortlaufend sein.

Aufgabe: Nummeriere die Datensätze

vom kleinsten bis zum größsten PK-Wert.

Das folgende MySQL-Script zeigt exemplarisch, wie

das machbar ist. Bedenke, dass die Bestimmung des

Rangs (gidf) nicht auf eine "echte" Tabelle beschränkt

ist, sondern auch mit einem View und dem Ergebnis

einer Abfrage durchgeführt werden kann.

Beispieltext: aysx Matthias Kopp 2013

create table aysx (

id int PRIMARY KEY,

remark varchar ( 64 ));

Tabelle mit Beispieldaten füllen.

insert into aysx ( id, remark ) values ( 1, 'Eins' );

insert into aysx ( id, remark ) values ( 512, 'FiveOneTwo' );

insert into aysx ( id, remark ) values ( 21, 'Antv' );

insert into aysx ( id, remark ) values ( 42, 'Antwort' );

insert into aysx ( id, remark ) values ( 23, 'whatever' );

Wesentlich ist der self-join. Der PK-Constraint garantiert,

dass jede aysx.id nur einmal vorkommt. Eine id ist immer

gleich ihrer selbst und alle anderen sind entweder größer

oder kleiner. Die where-Bedingung sucht diejenigen Datensätze

zusammen, die kleiner-gleich einer id sind - und das für

alle ids. Schließlich wird für jede id eine Gruppe gebildet

und die Anzahl der Elemente in der Gruppe ist eben der Rang.

select count(*) as rang, t2.id

from aysx t1, aysx t2

where t1.id <= t2.id

group by t2.id;

Ohne Gruppierung und Zählen - die "expandierte" Form.

Hier kann man nachvollziehen, welche Elemente vorhanden sind.

Zähle und gruppiere selbst!

select t1.id, t2.id

from aysx t1, aysx t2

where t1.id <= t2.id

order by t2.id

/* Auräumen. */

drop table aysx;

Natürlich ist das obige Beispiel so in der Praxis nicht vorgekommen. Das Beispiel zeigt eine nützliche Struktur. Im Laufe der Zeit kam immer wieder die Anforderung der Durchnummerierung. Man braucht dazu keinen PK-Constraint, aber wenigstens irgendein Tupel, das unique ist – und das findet sich. Jedenfalls konnte ich immer irgendwo eins auftreiben :)

Das Script oben habe ich mit Copy&Paste aus SQuirreL SQL übernommen, während ich mit einer MySQL-Datenbank verbunden war. Kann sein, dass andere RDBMS eine leicht abweichende Syntax haben. Aber im Prinzip sollte dieses Script auf gängigen SQL-Systemen lauffähig sein.

Publiziert am 6. Oktober 2013 von matthias | Kommentare deaktiviert

Daten konsistent halten

Publiziert am 6. Oktober 2013 von matthias

MySQL und andere RDBMS bieten die Möglichkeit, Foreign-Key-Constraints auszuschalten. Ich halte das für eine schlechte Idee.

Ich kenne aus der Praxis ein Szenario, bei dem FK-Constraints ausgeschaltet wurden, um den Import von Daten zu ermöglichen. Die Daten lagen in unterschiedlichen Tabellen, verknüpft durch Foreign Keys. Man kriegt die einen Daten nicht ‘rein, wenn die anderen Daten nicht vorhanden sind. Bei einem System mit vielen Tabellen und Verbindungen wird das schnell zu einer “Plage”, weil man sich über die Reihenfolge bei Export und Import Gedanken machen muss. Vielleicht sind in dem exportierten System bestimmte Datenstrukturen gar nicht vorhanden, weil das einen anderen Versionsstand hat als das System, in das hinein importiert wird. Es ist verlockend einfach, die Contraints auszuschalten, die Daten reinzupumpen und zu hoffen, dass alles gut geht. RDBMS mit einer strikten Vorgehensweise, Beispiel Oracle, erlauben es nicht, Constraints einzuschalten, solange inkonsistente Daten vorliegen. Und dann hat man zwei Probleme, nämlich inkonsistente Daten und fehlende Contraints, die wiederum zu weiteren Inkonsistenzen führen können. Wohl dem Kunden, der einen Supportvertrag hat :(

Foreign-Key-Contraints auszuschalten heisst, schnell und dreckig zu arbeiten. Manchmal wird einen der Arbeitsdruck dazu verleiten – es muss ein Weg gefunden werden und zwar flott. Ich kenne das. Und ich weiss, dass das Aufräumen inkonsistenter Daten mächtig viel Zeit in Anspruch nehmen kann. Foreign-Key-Contraints-ausschalten als Notnagel: Ja. Als Dauerlösung im Code: Nein!

Veröffentlicht unter Allgemein | Verschlagwortet mit foreign key, Konsistenz, mysql, sql | Kommentare deaktiviert

Refactoring php

Publiziert am 4. Oktober 2013 von matthias

Das erste aysx-Projekt wird sein, ein Warenwirtschaftssystem aufzumöbeln, das anno tuck in php programmiert wurde. Teile des Codes sind prozedural, andere objektorientiert.

Aufgabe ist, einen Schwung neue Features einzubauen und den Code mit aktuellem PHP und MySQL kompatibel zu machen.

Mit der Hilfe von Uncle Bob’s Weisheit lässt sich das sicher machen ;)

Veröffentlicht unter Allgemein | Kommentare deaktiviert

Hallo Welt,

hier ist aysx.

Ich hoffe, neben meiner Software-Tätigkeit im öffentlichen Dienst und dem bisschen Freelance-Coding für aysx Zeit zu finden, hier ein paar Gedanken niederzulegen, die vielleicht von allgemeinem Interesse sind.

Im Laufe der Jahre habe ich einige Kleinigkeiten gelernt, Kniffe und Tricks gefunden, die mir das Leben als Softwareentwickler leichter gemacht haben. Vielleicht interessiert’s ja wen. Ich denke da an java, sql, texttools, regular expressions, Teamwork, Kunden am Telefon … naja, das übliche, was man halt so macht bei bezahlter Arbeit.

Was ist aysx?

In Pulp Fiction sagt Butch zu Esmarelda Villalobos:

Ich bin Amerikaner, Süße, unsere Namen bedeuten einen Scheiß!

aysx bedeutet nichts. Es ist nur einfach zu tippen. Und genau so einfach soll Software sein: Gerade heraus. Kein Firlefanz. aysx ist mein Laden. Hier kann ich das verwirklichen, was ich für gute Software-Entwicklung halte.

Publiziert am 4. Oktober 2013 von matthias | Kommentare deaktiviert

Krüger, Guido: Handbuch der Java-Programmierung

Daten konsistent halten

Refactoring php

Neueste Beiträge

Archive

Kategorien

Meta