Fremdschlüssel-Attribute darstellen

[barnti]

Hallo alle,

ich habe da mal ne Frage (ach was?!).

Ich habe eine Tabelle 'Ansprechpartner'. Diese enthält ein Fremdschlüsselattribut 'Kunde_ID', welches die Zugehörigkeit des Ansprechpartners zu einem bestimmten Kunden abbildet. Nun meine Frage:

Gibt es eine einfache Möglichkeit bei der Darstellung eines Records der Tabelle 'Ansprechpartner' nicht das Fremschlüssel-Attribut selber anzuzeigen sondern stattdessen den Namen des Kunden?

Mit einer DBLookupComboBox kann man ja solche Beziehungen beim Anlegen eines neuen Datensatzes darstellen. Über die Werte 'KeyField','Listfield' usw. ist das ohne weiteres möglich. Aber wie ist es mit der generellen Darstellung, unterschieden in den eigenlichen Wert 'Kunde_ID' und die Darstellung dieses Wertes durch den eigenlich referenzierten Kunden also 'Kundenname'?!

Gibt es eine Möglichkeit? Vielleicht eine Komponente, die diese Anforderungen erfüllt?

Danke für euer Mitdenken, viele Grüße,

Barnti

[jlanger]

Wenn du mit einer Query arbeitest, dann kannst du den Wert gleich mit abfragen.
Wenn du mit einer Table arbeitest, kannst du im Feldeditor (die Table doppelklicken), alle Felde rhinzufügen, die du brauchst, falls nicht schon passiert. Anschliessend öffnest du mit der rechten Maustaste auf die Table "Neues Feld" und wählst dort "Lookup", da kannst du dann genau so die Beziehungen eingeben, um dieses Feld dann zu behandeln, als wäre es ein Feld der Tabelle (aber nur lesend).

Bei Fragen: Nur keine Scheu

[barnti]

Hallo jlanger,

das hört sich doch gut an. Da ich mit dynamischer Erzeugung aller Komponenten arbeite, fällt die Arbeit mit dem Editor leider aus. Aber dann muss ich das ganze zur Laufzeit zuweisen.
Ich arbeite komplett mit Query-Komponenten. Wie meinst Du das: "die Werte gleich mitabfragen? Ich greife im Moment mit der mysql-funktion "show Keys" auf die Eigenschaften der Tabellen-Attribute zu.
Hast Du ein Beispiel, wie ich neben der Abfrage der eigentlichen Tabellendaten gleich alle Attribute der Felder mitauslesen kann?
Es wäre schön, wenn ich jeder "Field" meines Ergebnissets gleich bei der Abfrage mit dem Eigenschaften der Felder versehen könnte. Aber wie speichere ich diese Eigenschaften der Felder? Oder gibt es bereits die Eigenschaft und ich habe diese übersehen.Lookup? Hört sich gut an. Hast Du näheres dazu?

Speziell: Lassen sich Lookup-Felder auch dynamisch zur Laufzeit erzeugen?

Danke für Dein Interessen. Ich freue mich auf Deine Anregungen,

Gruß,

Barnti

[barnti]

Zitat:

Du fragst doch die Felder der Tabelle ab mit

Source:
select * from TabelleA

oder mit
Source:
select Feld1, Feld2, Kunden_Id, FeldXyz from TabelleA

oder etwa nicht?

dann kannst du doch auch gleich abfragen

Source:
select A.Feld1, A.Feld2, A.Kunden_ID, B.Name, B.Nachname
from TabelleA A
inner join Kundentabelle B ON (A.Kunden_ID=B.ID)


Etwas anderes ist das mit dem LokupFeld,
Man kann auch der Query dynamisch zur Laufzeit alle Felder hinzufügen lassen (ist dann als ob man sie im Feld-Editor hinzugefügt hätte) und dann ein solches Lookup-Feld hinzufügen.
Das ist aber etwas Arbeit.

Am einfachsten ist es doch, die Felder aus den entsprechenden Tabellen gleich mit abzufragen (wie oben).

Grüß Dich jlanger!

Ja das klingt zwar nett, aber: Ich möchte meine DB-Oberfläche möglichst dynamisch erzeugen. Soll Heißen beim Start der Anwendung wird für jede Tabelle eine Query erzeugt. Je nach Inhalt der Tabelle soll auch das zugehörige SQL-Statement generiert werden. Z.B.:

Tabelle Kunde->
Select * from Kunde So weit so gut. Damit habe ich dann eine Abrage, die mir alle Felder der Tabelle liefert. Das Dumme ist, das ich für die Darstellung meiner Tabellen jeweils ein DBGrid verwende. Wenn ich nun die Tabellen-Daten darstelle, bekomme ich auch nur die Felder die vorhanden sind.

Du hast Recht: ich könnte das Statement mit einem Join versehen, so dass ich die Daten in meinem Dataset habe. Das ist bei einer dynamischen Erzeugung allerdings nicht so ohne weiteres möglich, denn dafür brauche ich ja die Fremdschlüssel jeder Tabelle, und die zu referenzierenden Werte aus der Detail-Tabelle.

Du hast auch Recht: die dynamische Erzeugung der Lookupfelder ist aufwendig.

Meine bisherige theoretische Lösung sieht wie folgt aus:

Ich benenne in der DB alle Fremdschlüssel nach dem Prinzip: 'Tabellenname'+'_'+'Anzeigename'

Beispiel:

Tabelle Kunde:

Kunde_ID
Kundenname

Tabelle Bestellung

Bestellung_ID
ProduktName
Kunde_ID

=> in der Tabelle "Bestellung" existiert ein Fremschlüssel diesen nenne ich dann: "Kunde_Kundenname".

Wenn ich jetzt im Programm meine Query erzeuge, frage ich mit "Show keys from 'DB-Name'+'.'+'Tabellenname'" die Schlüsselfelder ab. Als Namen bekomme ich dann für die Tabelle "Bestellung": 'Kunde_Kundenname'. Dieses Ergebnis der Abfrage muss ich dann noch trennen in 'TabellenName' und 'FeldName'. Damit habe ich das Lookup.

Mein SQL-Statement ergänzt sich dann:

SQL-Code:

select Bestellung.*,Kunde.KundenName
from Bestellung, Kunde

Alles klar?
Ich sehe keine einfachere Möglichkeit. Vielleicht hast Du ja noch eine Idee!?

Ich freu mich auf Deine Antwort,

Gruß, Barnti

P.S.: Ich habe die Nachricht auch noch einmal zum aktuellen thread gepostet

[barnti]

Zitat:

Das Statement müsste dann schon heissen:

Code:

select Bestellung.*,Kunde.KundenName
from Bestellung, Kunde
where Bestellung.Kunde_ID = Kunde.ID

sonst bekommst du doch sehr viele Treffer (alle Kombinationen)

OK, Du kannst einer Query alle Felder zur Laufzeit erzeugen lassen. Dann sind sie greifbar (vorhanden) als hättest du sie im Feldeditor mit "Alle Felder hinzufügen" hinzugefügt. Anschliessend kann man mit deiner Feldnamenlogik dann ja ein Lookup-Feld erzeugen lassen. Das ist genau das was ich meinte.
Bei Bedarf kann ich dir beschreiben wie das ganze geht. (Das Lookup-Feld zur Laufzeit hinzufügen muss ich selber mal nachschauen/testen).

Hast natürlich Recht. Das hatte ich im Statement unterschlagen. Dank Dir für die Mühe, ich freue mich näheres zu erfahren.

Gruß,

Barnti