SQL Wie bekomm ich das in eine DB

A

Apocalypse81

0
Hallo zusammen,
ich bin gerade dabei eine kleine Web-Anwendung zu schreiben. Dazu gehört natürlich auch eine Rechte-Verwaltung für das User-Management.... Leider habe ich eine Vorgabe, wie das ganze aufgebaut werden soll.... und zwar so:

Code: 
create_ticket 0000000000000000000000000000000000000000000000000000000000000001
view_ticket 0000000000000000000000000000000000000000000000000000000000000010
edit_ticket 0000000000000000000000000000000000000000000000000000000000000100
close_ticket 0000000000000000000000000000000000000000000000000000000000001000
archive_ticket 0000000000000000000000000000000000000000000000000000000000010000
delete_ticket 0000000000000000000000000000000000000000000000000000000000100000
_ticket 0000000000000000000000000000000000000000000000000000000001000000
_ticket 0000000000000000000000000000000000000000000000000000000010000000
create_file 0000000000000000000000000000000000000000000000000000000100000000
view_file 0000000000000000000000000000000000000000000000000000001000000000
move_file 0000000000000000000000000000000000000000000000000000010000000000
archive_file 0000000000000000000000000000000000000000000000000000100000000000
delete_file 0000000000000000000000000000000000000000000000000001000000000000
_file 0000000000000000000000000000000000000000000000000010000000000000
_file 0000000000000000000000000000000000000000000000000100000000000000
_file 0000000000000000000000000000000000000000000000001000000000000000
create_contract 0000000000000000000000000000000000000000000000010000000000000000
change_contract 0000000000000000000000000000000000000000000000100000000000000000
archive_contract 0000000000000000000000000000000000000000000001000000000000000000
_contract 0000000000000000000000000000000000000000000010000000000000000000
_contract 0000000000000000000000000000000000000000000100000000000000000000
_contract 0000000000000000000000000000000000000000001000000000000000000000
_contract 0000000000000000000000000000000000000000010000000000000000000000
_contract 0000000000000000000000000000000000000000100000000000000000000000
create_group 0000000000000000000000000000000000000001000000000000000000000000
change_group 0000000000000000000000000000000000000010000000000000000000000000
delete_group 0000000000000000000000000000000000000100000000000000000000000000
_group 0000000000000000000000000000000000001000000000000000000000000000
_group 0000000000000000000000000000000000010000000000000000000000000000
_group 0000000000000000000000000000000000100000000000000000000000000000
_group 0000000000000000000000000000000001000000000000000000000000000000
_group 0000000000000000000000000000000010000000000000000000000000000000
create_user 0000000000000000000000000000000100000000000000000000000000000000
change_user 0000000000000000000000000000001000000000000000000000000000000000
setgroup_user 0000000000000000000000000000010000000000000000000000000000000000
changegroup_user 0000000000000000000000000000100000000000000000000000000000000000
delete_user 0000000000000000000000000001000000000000000000000000000000000000
_user 0000000000000000000000000010000000000000000000000000000000000000
_user 0000000000000000000000000100000000000000000000000000000000000000
_user 0000000000000000000000001000000000000000000000000000000000000000
send_message 0000000000000000000000010000000000000000000000000000000000000000
read_message 0000000000000000000000100000000000000000000000000000000000000000
reply_message 0000000000000000000001000000000000000000000000000000000000000000
archive_message 0000000000000000000010000000000000000000000000000000000000000000
delete_message 0000000000000000000100000000000000000000000000000000000000000000
_message 0000000000000000001000000000000000000000000000000000000000000000
_message 0000000000000000010000000000000000000000000000000000000000000000
_message 0000000000000000100000000000000000000000000000000000000000000000
send_mail 0000000000000001000000000000000000000000000000000000000000000000
_mail 0000000000000010000000000000000000000000000000000000000000000000
_mail 0000000000000100000000000000000000000000000000000000000000000000
_mail 0000000000001000000000000000000000000000000000000000000000000000
_mail 0000000000010000000000000000000000000000000000000000000000000000
_mail 0000000000100000000000000000000000000000000000000000000000000000
_mail 0000000001000000000000000000000000000000000000000000000000000000
_mail 0000000010000000000000000000000000000000000000000000000000000000

Nur habe ich leider keine Ahnung, wie ich das so in meine DB pressen kann, dass ich hinterher auch damit arbeiten kann.
Wenn mir hier jemand einen Denkanstoß hätte, wäre ich echt dankbar =)
 
Die Struktur einer DB hängt sehr davon ab wie die Daten im Endeffekt weiterverarbeitet werden sollen. Musst du lediglich die Rechte anhand der "Masks" (oder was auch immer das sonst sein soll) auflösen können, sollten 2 Spalten in einer Tabelle reichen. Einen Index setzt man dann auf die Spalte, die bei WHERE oder SORT-Statements verwendet wird.
 
Das Chaos da oben sind einzelne Rechte. Aus denen sollen dann für jeden User die Rechte für die einzelnen Bereiche zusammengesetzt werden.
Also im Prinzip so:
Code: 
 00000001  Recht1
+00000010 Recht2
----------
=00000011 Rechte für den User

Ich hoffe ich drück mich nicht falsch oder zu komplliziert aus... das passiert mir ganz gerne mal :-)

In der Vergangenheit habe ich das immer so gemacht:
Code: 
 1  Recht1
+2 Recht2
--
=3 Recht für den User

Nur ist das in diesem Fall leider nicht erwünscht (was nicht auf meinem Mist gewachsen ist)
 
Zuletzt bearbeitet:
benediktibk hat gesagt.:
Ich sehe da in den beiden Lösungen von dir keinen Unterschied.

mfg benediktibk
Zum Vergrößern anklicken....

Gibt eigentlich auch keinen... Nur dass ich das in diesem Fall eben nicht mit int -Werten machen soll sondern mit diesem lustigen Bit-Muster. Von der programmiertechnischen Seite wäre das ja auch kein Problem, aber ich bekomm das Ganze nicht so in die DB geschrieben dass ich hinterher auch was damit anfangen kann.
 
Ähm.. Wenn ein Benutzer das Recht 7 besitzt, welche Berechtigungen besitzt er dann effektiv? 1+2+4 oder 3+4? Du musst dir weitaus mehr Gedanken machen und kannst letzten Endes nur 2er-Potenzen nutzen. Binär wäre die Sache klar (nämlich 1,2 und 4), wobei du zusätzlich noch recht einfach Binäroperationen implementieren kannst.

Ganz unabhängig davon: Wo liegt dein Problem? Du legst eine Spalte dafür an (im simpelsten Falle eine Tabelle mit den Spalten String(255) und String(65)) und wandelst den String innerhalb des Codes in ein Binary-Array um.
 
Zuletzt bearbeitet:
SchwarzeBeere hat gesagt.:
Ähm.. Wenn ein Benutzer das Recht 7 besitzt, welche Berechtigungen besitzt er dann effektiv? 1+2+4 oder 3+4?
Zum Vergrößern anklicken....

Hat ein User das Recht 7, dann muss es sich aus 1+2+4 zusammensetzen. Die Zahl 3 ist keine 2er-Potenz und kann daher nicht vorkommen.

SchwarzeBeere hat gesagt.:
Ganz unabhängig davon: Wo liegt dein Problem? Du legst eine Spalte dafür an (im simpelsten Falle eine Tabelle mit den Spalten String(255) und String(65)) und wandelst den String innerhalb des Codes in ein Binary-Array um.
Zum Vergrößern anklicken....

Das ist ja eben meine Frage (nur dass ich es wie all zu oft zu kompliziert ausgedrückt habe) : Gibt es keine Möglichkeit das direkt als Datentyp bit abzulegen.
So dass ich mir dann das Umrechnen sparen kann....
 
Speicher es als String, dann ist der Chef zufrieden, weil er es "sehen" und fassen kann. In Anbetracht der Tatsache, dass ihr >8 Byte speichern wollt, würden alternativ noch BLOBs in Frage kommen (bzw. auch andere Datentypen, nur ist mir nicht bekannt, ob und welche ihr SQL-Lösung einsetzt oder welche Programmiersprachen ihr nutzt).

Nebenbei: Da ihr >8 Bytes habt solltet ihr euch eher eventuell ne geeignete Datenstruktur ausdenken (Integer ist zu klein, BigInt hat 8 Byte) und die Datenbank daran ausrichten, anstatt euren Code an die Datenbank anzupassen.
 
Zuletzt bearbeitet:
Werde ich dann wohl oder übel so machen müssen....
Der Hintergrund ist wohl der, dass der Auftraggeber für diese Seite irgendwann mal gehört hat, dass alles was auf Bit-Ebene stattfindet mit einer irrsinnigen Geschwindigkeit berechnet werden kann... Bei Seiten wie Facebook mag das ja sogar ne Rolle spielen... aber hier?? Na ja.. Der Kunde ist König und der Programmierer der Leidtragende...X(
Verwendete Programmiersprachen sind übrigens hauptsächlich PHP und Jquery... die DB ist derzeit noch MySQL, wird aber wohl noch auf Postgres umgestellt...
Danke erstmal :-)
 
Warum nicht so:
User und Rechte in eigenen Tabellen mit eindeutiger id halten.
Und diese über eine Verknüpfungstabelle (bspw. mit den Spalten UserID und RechtID) miteinander verknüpfen, sodass eine n zu m Relation entsteht.

So wie du es meinst könnte man die Rechte auch in die Usertabelle übernehmen und für jedes Recht eine Spalte hinzufügen, welche dem Datentyp Boolean (Tinyint(1)) entsprechen würde. (Ist aber nicht ganz so schön zu pflegen und anzusehen)
 
Das Verwalten der Rechte an sich ist eigentlich nicht das Problem... das Problem war, dass ich die Werte nicht in die Tabelle gekriegt habe, dass es für den Kunden schön aussieht wenn er sich´s mal zeigen lässt, was da so alles drin steht (siehe meinen Post weiter oben). Die Rechte an sich werden einfach zusammengezählt und dann in der User-Tabelle abgelegt. So, wie sich das eben gehört :)
m zu n Beziehngen versuche ich übrigens so gut wie möglich zu vermeiden, wegen der Gefahr, dass man redundante Daten erhält, die die Tabellen wertlos machen =)
 
Also ein Eintrag besteht aus 64 bit und somit 8 Byte <-- verstanden
Oder reden wir hier von Wörten?

Was representiert denn ein Recht für den Nutzer. 1 Bit aus den gesamten 8 Bytes (macht wenig Sinn), oder eine Position aus den 8 Bytes(macht auch wenig Sinn).

Oder sind die 8 bytes untergliedert in r/w/x etc...?

und warum ist _mail z.B. 7 mal enthalten, wenn es nur ein Recht beschreibt ?

Was wird beim einstieg in dei Anwendung geprüft (summe aus dem ganzen)
Würde Dir gerne helfen, würde mich aber über ein wenig mehr inpu freuen!
Versuche das ganze doch mal an einem Beispiel zu erklären .

greetz :)
 
Der Grund, dass _mail gleich 7 mal vorkommt ist der, dass ich für jede Rechte-Rubrik 8 Bit reservieren soll. Frag mich aber bitte nicht nach dem Sinn des Ganzen. Ich bin nur der arme kleine Mann, der das, was er als Vorgabe hat umsetzen soll. Wenn ich dir jetzt noch schreibe, dass der ganze Quatsch da oben auch noch per in der DB zu jedem User abgelegten XML spezifiziert werden soll, hältst du mich vermutlich für vollkommen durchgedreht.

Also: Immer eine Oktette repräsentiert quasi eine Rechte-Rubrik. Sachen wie '_rubrik ' bedeuten, dass hier noch keine Verwendung für das zugehörige Bit existiert.

Das ganze sind Einzelrechte. Aus denen werden dann für jeden User die Rechte zusammengeschraubt, die dann auch noch per XML spezifiziert werden (wie viel, wie groß, welche Art etc).
Dass das Ganze wenig Sinn macht sehe ich nicht so: Ich kann hier eine sehr feine Abstimmung der Rechte für einzelne User machen. Von dem her passt das glaub schon. Die Geschichte ist nur leider nicht sehr übersichtlich, das seh ich ein...
Wäre es sinnvoll, wenn ich aus jeder einzelnen Rubrik eine eigene Tabelle machen würde? Ich vermute zwar fast, dass das wenig Sinn macht, aber ist halt auch so ein Gedanke, der mir gerade gekommen ist....
 
Irgendwie bin ich noch nicht auf Deinem Niveau !?

Immer eine Oktette repräsentiert quasi eine Rechte-Rubrik
Zum Vergrößern anklicken....

Rubrik = Link
Oktette = 1 Byte

Also hast Du 8 Möglichkeiten an Rechte zu vergeben ..., wobei ein Byte r/w/x für einen Teil der Application beinhaltet.

Häh ...

Sry, ich muss mir das ganze noch einmal in Ruhe auf mich wirken lassen, denn mir kreuseln sich die Haare (ich raff das nicht ...)
 
ByteSurfer hat gesagt.:
Irgendwie bin ich noch nicht auf Deinem Niveau !?



Rubrik = Link
Oktette = 1 Byte

Also hast Du 8 Möglichkeiten an Rechte zu vergeben ..., wobei ein Byte r/w/x für einen Teil der Application beinhaltet.

Häh ...

Sry, ich muss mir das ganze noch einmal in Ruhe auf mich wirken lassen, denn mir kreuseln sich die Haare (ich raff das nicht ...)
Zum Vergrößern anklicken....

Da geht es dir, wie es mir am Anfang ging, als ich den Auftrag bekommen hab...

Mit Rechte-Rubrik sind keine Links gemeint. Eher so in der Art: Datei-Rechte, Ticket-Rechte, Gruppen-Rechte etc.

Hier wird eigentlich lediglich festgelegt, ob ein User etwas darf oder ob nicht... Wie viel und wie oft er etwas darf wird dann per XML festgelegt :-)
 
du solltest dich zum wohle deines auftraggebers nochmals mit diesem an einen tisch setzen:

speichern und verarbeiten auf bit ebene ist toll, nur nicht schön zu pflegen ...

schlage ihm vor das gesammte rechtesystem relational normalisiert zu speichern und zu verwalten ...

für die geschwindigkeit kann man danach auf caches gehen, die binärdaten enthalten und pro user/etc abgelegt werden ... diese caches sind redundante daten ... sie werden bei einer aktualisierung aus den relationalen daten gebildet (schreibt man sich einmal ne funktion für ... kann man ggf auch als stored procedure / trigger ablegen, zwecks automatisierung)

um dann schnell mit den daten arbeiten zu können kann man dann per boolscher verknüpfung und maskenbildung die effektiven rechte auswerten, und zu verwaltungszwecken mit einer relationalen normalisierten datenbank arbeiten...

ein weiterer vorteil zeigt sich bei änderungen der binärstruktur ...

will ich bei einem statischen binärschema wie es der auftraggeber wünscht die struktur ändern wirds meist sehr schnell aufwändig ... (und damit meist teurer)

habe ich die daten in einer relationalen normalisierten db sind hinzugefügte rechte gruppen etc sehr einfach und schnell machbar ... danach baut man die funktion(en) um, die das in binärdaten umrechnet (also die einzelnen caches füllt), und kann die caches neu erzeugen ...

das ganze hat auch den vorteil, dass man die caches an die jeweilige aufgabe anpassen kann: warum alle rechte-daten laden wenn man auf der aktuellen seite nur bestimmte gruppen braucht ... also baut man einen cache den diese seite benutzt ... andere seite, andere rechte gruppen -> anderer cache ... das kann man entweder je seite machen, um möglichst pro seitenaufruf nur genau einen user rechte cache zu holen ... oder funktionalitätsbezogen, also alles was zum thema xy gehört kommt in den selben cache

was spart man sich dadurch? das prüfen der rechte geht wirklich schneller ...braucht ein user für einen bestimmten code zweig bestimmte rechte, bildet man aus diesen rechten im vorfeld eine "oder" verknüpfung (stichwort "bitmap") ... heraus kommt eine zahl ... die user rechte aus dem cache sind auch ein bitmap ...

danach kann ich sowas machen:

if((user_rechte_aus_cache & benoetigte_rechte) == benoetigte_rechte )

... wenn ich das mit 64 bit integern mache, kann ich bis zu 64 rechte gleichzeitig mit einem if prüfen ... ich darf halt nur nicht im code hingehen und erstmal mühsam mein bitmap für die benötigten rechte jedesmal aufs neue zusammenbauen ... das muss bereits als eine zahl da liegen

man gewinnt halt performance durch das vorrausberechnen bestimmter werte (hier die bitmaps aus dem cache und die rechte maske ...) da die sich nicht häufig ändern und bei den jeweiligen berechnungen immer aufs neue der gleiche wert berechnet würde ... so macht man es nur dann wenn der wert sich ändert und arbeitet mit dem vorrausberechneten wert


ein wort zur warnung:
binäre bitmaps eignen sich nicht um rechte zu einzelnen objekten zu verwalten

hast du also eine variable anzahl von entitäten, zu denen benutzer rechte bekommen sollen, wirst du das nicht über ein bitmap machen können, weil dir schlicht die bits in deinem rechte feld ausgehen, und du in der regel bitmaps mit maximal 64 bits prüfen willst (wortbreite eines 64 bit systems)
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben