welche grundsätze sollte ich bei der eingabe von daten in eine komplexe relationale datenbank beachten?
<p>ich bin neu in datenbanken. verzeihen sie mir, wenn dies eine grundlegende frage ist.</p><p>ich versuche, ein komplexes open source-wörterbuch zu analysieren und die daten in eine access-datenbank auszugeben, die ebenso komplex ist:</p><p> <a href="https://i.stack.imgur.com/vvrqn.png">(<img src="https://i.stack.imgur.com/vvrqn.png" alt="enter image description here"></a> </p><p>ich verstehe, wie man daten in eine tabelle einfügt, aber ich verstehe nicht, wie man daten in mehrere tabellen einfügt, die für fremdschlüssel aufeinander angewiesen sind. um ein vereinfachtes beispiel zu geben:</p><p>ich habe drei tabellen: <code>entry</code>, <code>keyword</code> und <code>keyword\_priority</code>. jeder eintrag kann mehrere schlüsselwörter enthalten, sodass die tabelle <code>keyword</code> über einen fremdschlüssel mit <code>entry</code> verknüpft ist. und jedes schlüsselwortelement kann mehrere elemente enthalten, die die priorität des schlüsselworts beschreiben, sodass die tabelle <code>keyword\_priority</code> wie folgt über einen fremdschlüssel auf <code>keyword</code> zurückverweist:</p><p> <a href="https://i.stack.imgur.com/l3dev.png">(<img src="https://i.stack.imgur.com/l3dev.png" alt="enter image description here"></a> </p><p>angenommen, ich möchte in diesem vereinfachten szenario einen neuen eintrag mit sql erstellen. wo soll ich anfangen? muss ich:</p><ol> <li> <p>fügen sie zuerst in die tabelle <code>entry</code> ein, um ein neues <code>entryid</code> zu erstellen</p> </li> <li> <p>fügen sie dann mit dem neuen <code>keyword</code> als fremdschlüssel in die tabelle <code>entryid</code> ein</p> </li> <li> <p>fügen sie dann in die tabelle <code>keyword\_priority</code> ein, indem sie das feld <code>id</code> des schlüsselworts als fremdschlüssel verwenden</p> </li> </ol><p>oder alternativ sollte ich es umgekehrt machen ...</p><ol> <li> <p>in die tabelle <code>keyword\_priority</code> einfügen</p> </li> <li> <p>in die tabelle <code>keyword</code> einfügen</p> </li> <li> <p>in die tabelle <code>entry</code> einfügen</p> </li> </ol><p>zusammenfassend lautet meine frage:</p><p>wo soll ich anfangen, wenn ich daten gleichzeitig in mehrere tabellen einfüge? von oben nach unten oder von unten nach oben?</p>
<p>ein fremdschlüssel bezieht sich auf den primärschlüssel einer anderen tabelle. wenn der datensatz mit dem fremdwort eingegeben wird, muss der entsprechende datensatz mit diesem primärschlüssel vorhanden sein. daher müssen sie immer mit dem einfügen in die tabellen auf der 1-seite der beziehung (der master- oder eltern- oder primärschlüsseltabelle) beginnen. dann können nur sie einen datensatz auf der n-seite der beziehung eingeben (in die detail- oder kind- oder fremdschlüsseltabelle).</p><p>reihenfolge: 1. eintrag, 2. schlüsselwort, 3. schlüsselwortpriorität.</p><p>wenn eine tabelle mehrere fremdschlüssel enthält, müssen zuerst die zugehörigen datensätze in allen anderen tabellen mit den entsprechenden primärschlüsseln eingegeben werden. zum beispiel vor der eingabe eines datensatzes in <code>senserestricted...</code> müssen die entsprechenden datensätze in <code>sense</code> und in <code>reading</code> eingefügt worden sein.</p>
<p>es gibt optionen, die ihnen dabei helfen:</p><pre><code> --insert-ignore insert rows with insert ignore. --replace use replace into instead of insert into. -t, --no-create-info don't write table creation info. </code></pre><p>denken sie an dieses paradigma</p><ul> <li>mysqldump alles von db1 in dump1</li> <li>laden sie dump1 in db3</li> <li>mysqldump alles aus db2 mit --replace (oder --insert-ignore) und --no-create-info in dump2</li> <li>laden sie dump2 in db3</li> </ul> <p>hinweis: ab azure sql database v12 gelten diese einschränkungen nicht mehr.</p><p>das ist kein "primärindex". es gibt so etwas wie einen "primärschlüssel" und es gibt auch so etwas wie einen "clustered index". unterschiedliche konzepte, oft verwirrt. lassen sie uns angesichts dieser unterscheidung die frage noch einmal betrachten:</p><p>q1) kann der clustered-index in einer sql azure-tabelle geändert werden?<br> a: ja. verwenden sie <code>with (drop\_existing=on)</code>:</p><pre><code>create table friend ( userid int not null, id int not null); go create clustered index cdxfriend on friend (userid, id); go create clustered index cdxfriend on friend (id, userid) with (drop\_existing=on); go </code></pre><p>f2) kann der clustered-index einer tabelle mit einer primärschlüsseleinschränkung geändert werden?<br> a: ja, wie oben, solange die primärschlüsseleinschränkung nicht über den clustered-index erzwungen wird:</p><pre><code>create table friend ( userid int not null, id int not null identity(1,1), constraint pk\_friend primary key nonclustered (id)); create clustered index cdxfriend on friend (userid, id); go create clustered index cdxfriend on friend (id, userid) with (drop\_existing=on); go </code></pre><p>f3) kann die primärschlüsseleinschränkung einer tabelle geändert werden?<br> a: ja, solange die primäre einschränkung nicht über den clustered-index erzwungen wird:</p><pre><code>create table friend ( userid int not null, id int not null identity(1,1), constraint pk\_friend primary key nonclustered (id)); go create clustered index cdxfriend on friend (userid, id); go alter table friend drop constraint pk\_friend; alter table friend add constraint pk\_friend primary key nonclustered (userid) go </code></pre><p>f4) kann der primärschlüssel einer tabelle geändert werden, wenn er über den clustered-index erzwungen wird?<br> a: ja, wenn die tabelle nie zeilen hatte:</p><pre><code>create table friend ( userid int not null, id int not null identity(1,1), constraint pk\_friend primary key clustered (userid, id)); go alter table friend drop constraint pk\_friend; alter table friend add constraint pk\_friend primary key clustered (id, userid) go </code></pre><p>f5) kann der primärschlüssel einer tabelle geändert werden, wenn er über den clustered-index erzwungen wird, wenn die tabelle gefüllt ist?<br> a: nein. jede operation, die einen aufgefüllten clustered-index in einen heap konvertiert, wird in sql azure blockiert <em>, auch wenn die tabelle leer ist </em>:</p><pre><code>create table friend ( userid int not null, id int not null identity(1,1), constraint pk\_friend primary key clustered (userid, id)); go insert into friend (userid) values (1); delete from friend; go alter table friend drop constraint pk\_friend; </code></pre><p>als randnotiz: die einschränkung kann geändert werden, wenn die tabelle <em> abgeschnitten ist </em>.</p><p>die problemumgehung zum ändern der pk-einschränkung einer aufgefüllten tabelle besteht darin, das gute alte <a href="http://msdn.microsoft.com/en-us/library/ms188351.aspx"><code>sp\_rename</code></a> trick:</p><pre><code>create table friend ( userid int not null, id int not null identity(1,1), constraint pk\_friend primary key clustered (userid, id)); go insert into friend (userid) values (1); go create table friendnew ( userid int not null, id int not null identity(1,1), constraint pk\_friend\_new primary key clustered (id, userid)); go set identity\_insert friendnew on; insert into friendnew (userid, id) select userid, id from friend; set identity\_insert friendnew off; go begin transaction exec sp\_rename 'friend', 'friendold'; exec sp\_rename 'friendnew', 'friend'; commit; go sp\_help 'friend'; </code></pre><p>das <code>sp\_rename</code> ansatz hat einige probleme, vor allem, dass berechtigungen für die tabelle während des umbenennens nicht übertragen werden, sowie fremdschlüsseleinschränkungen.</p> so wie gewünscht, geht das ganz einfach = wenn die seitenummer auf seite 3 beginnen soll, dann so= auf die seite 2 mit dem curser gehn- dann -einfügen-manueller umbruch-seitenumbruch-vorlage - erste seite - seitennummer ändern-1 setzen - bestätigen- fertig, nun kann man deckblatt usw. bearbeiten. so nun ist die seite drei die erste seite= einfügen - fußzeile -standard- ok. einfügen-feldbefehl-seitennummer - ok. fertig. das geht natürlich so auch nach dem selbensystem mit der kopfzeile. mfg.m. Es lohnt sich, einen Blick auf diesen [`Blog Post`](http://lostechies.com/jimmybogard/2012/07/20/choosing-an-orm-strategy/) werfen, aber letztendlich werden die Kriterien von Ihnen festgelegt. Sie müssen entscheiden, ob 

* schnelle Entwicklung
* Performance
* Code-zuerst
* DB zuerst

 oder was auch immer Sie suchen und priorisieren Sie die Liste basierend auf, was noch wichtiger ist. Dann verwenden Sie diese Liste, um Ihre Forschung zusammenzustellen. Sie können verwenden 


```
DbConfiguration.SetConfiguration(new YourDbConfiguration());

```
  Sie können also Ihre Konfiguration verwenden, ohne ein Attribut zu verwenden. 

 Aber wenn ich benutze 


```
public CeDbConfiguration()
{
 SetDefaultConnectionFactory(new SqlCeConnectionFactory(SqlCeProviderServices.ProviderInvariantName,
                                                        @"c:\test",
                                                        @"c:\test\db.sdf"));
SetProviderServices(SqlCeProviderServices.ProviderInvariantName,
                    SqlCeProviderServices.Instance);
}

```
  Um eine SQL CE Factory zu konfigurieren, wird der Pfad *'C: \ test'* ignoriert und ich muss auch Database.DefaultConnectionFactory setzen !! Aloha :)


Ich hoffe, dass ich den Aufbau der Determinante richtig verstanden habe. Um die Idee zu verdeutlichen, schreibe ich die ersten 4 Fälle einfach mal auf:


Bei \(n=1\) ist nicht viel zu tun:$$D\_1=\left|\begin{array}{c}1\end{array}\right|=1$$


Bei \(n=2\) addiere ich Zeile 1 zu Zeile 2 und ziehe danach aus Zeile 2 den Faktor vor die Determinante:$$D\_2=\left|\begin{array}{c}1 & 1\\-1 & 1\end{array}\right|=\left|\begin{array}{c}1 & 1\\0 & 2\end{array}\right|=2\cdot\left|\begin{array}{c}1 & 1\\0 & 1\end{array}\right|=2$$
  



Bei \(n=3\) addiere ich Zeile 1 zu Zeile 2 und ziehe danach aus Zeile 2 den Faktor vor die Determinante:$$D\_3=\left|\begin{array}{c}1 & 1 & 0\\-1 & 1 & 4\\0 & -1 & 1\end{array}\right|=\left|\begin{array}{c}1 & 1 & 0\\0 & 2 & 4\\0 & -1 & 1\end{array}\right|=2\cdot\left|\begin{array}{c}1 & 1 & 0\\0 & 1 & 2\\0 & -1 & 1\end{array}\right|$$Jetzt addiere ich weiter Zeile 2 zu Zeile 3 und ziehe aus Zeile 3 den Faktor vor:$$\phantom{D\_3}=2\cdot\left|\begin{array}{c}1 & 1 & 0\\0 & 1 & 2\\0 & 0 & 3\end{array}\right|=2\cdot3\cdot\left|\begin{array}{c}1 & 1 & 0\\0 & 1 & 2\\0 & 0 & 1\end{array}\right|=6$$


Bei \(n=4\) wiederhole ich zunächst alle Schritte vom Fall \(n=3\):


$$D\_4=\left|\begin{array}{c}1 & 1 & 0 & 0\\-1 & 1 & 4 & 0\\0 & -1 & 1 & 9\\0 & 0 & -1 & 1\end{array}\right|=\left|\begin{array}{c}1 & 1 & 0 & 0\\0 & 2 & 4 & 0\\0 & -1 & 1 & 9\\0 & 0 & -1 & 1\end{array}\right|=2\cdot\left|\begin{array}{c}1 & 1 & 0 & 0\\0 & 1 & 2 & 0\\0 & -1 & 1 & 9\\0 & 0 & -1 & 1\end{array}\right|$$$$\phantom{D\_4}=2\cdot\left|\begin{array}{c}1 & 1 & 0 & 0\\0 & 1 & 2 & 0\\0 & 0 & 3 & 9\\0 & 0 & -1 & 1\end{array}\right|=2\cdot3\cdot\left|\begin{array}{c}\underline1 & \underline1 & \underline0 & 0\\\underline0 & \underline1 & \underline2 & 0\\\underline0 & \underline0 & \underline1 & 3\\0 & 0 & -1 & 1\end{array}\right|$$Man erkennt die letzte Determinante aus der Berechnung von \(D\_3\) wieder (unterstrichene Einträge), nur sind jetzt noch die 3 Elemente in der rechten unteren Ecke dazu gekommen, alle anderen zusätzlichen Einträge sind 0. Wir können daher noch einen weiteren Schritt (Addition der vorletzten Zeile zur letzten und Faktor herausziehen) durchführen:$$\phantom{D\_4}=2\cdot3\cdot\left|\begin{array}{c}1 & 1 & 0 & 0\\0 & 1 & 2 & 0\\0 & 0 & 1 & 3\\0 & 0 & 0 & 4\end{array}\right|=2\cdot3\cdot4\cdot\left|\begin{array}{c}1 & 1 & 0 & 0\\0 & 1 & 2 & 0\\0 & 0 & 1 & 3\\0 & 0 & 0 & 1\end{array}\right|=24$$


Damit ist klar, dass: \(D\_n=n!\)


Dieses Vorgehen kannst du, wenn verlangt, noch in einen sauberen Induktionsbeweis packen. Die Beweisidee sollte zumindest jetzt klar sein ;) 1. Erstellen Sie eine neue ASP.NET-Webanwendung mit dem Namen "WebProject" mithilfe der Webanwendungsvorlage (Authentifizierung: Benutzerkonto).
2. Fügen Sie der Lösung mit dem Namen "DataAccess" ein weiteres Projekt hinzu (sagen wir Klassenbibliotheksart, obwohl diese nicht relevant ist)
3. Verschieben Sie jetzt den Ordner ApplicationDbContext / ApplicationUser files & migrations in das DataAccess-Projekt.
4. In diesem Stadium wird die Erstellung fehlschlagen, daher müssen wir die project.json für korrekte Referenzen korrigieren.
5. Fügen Sie für DataAccess-Projekt folgende Abhängigkeiten hinzu 


```
"dependencies": {
    "Microsoft.AspNet.Identity.EntityFramework": "3.0.0-rc1-final",
    "EntityFramework.MicrosoftSqlServer": "7.0.0-rc1-final"
}

```
6. Fügen Sie für WebProject `DataAccess` als Abhängigkeit hinzu. Da `DataAccess` auf zwei Pakete verweist, können Sie diese Referenzen aus WebProject entfernen.   
 Build sollte nun erfolgreich sein und Sie können eine Webanwendung starten.

 So verwenden Sie ef-Migrationen: 

 Wechseln Sie in der Befehlszeile in das Verzeichnis von WebProject (und nicht das DataAccess-Projekt). Alle ef-Befehle funktionieren von hier aus gut. 

 Um neue Migrationen zum Migrationsordner des DataAccess-Projekts hinzuzufügen, müssen Sie die Option `-p` verwenden. Mögen,   
 `dnx ef migrations add Sample -p DataAccess` . 

 Das Problem tritt auf, weil die Befehle von cmd im DataAccess-Projekt ausgeführt werden. Ihre Startup-Klasse, die alle Dienste initialisiert, befindet sich in WebProject. Wenn Sie versuchen, Befehle aus dem DataAccess-Verzeichnis auszuführen, wird `dnx ef` erkannt, da auf `EntityFramework.Commands` verwiesen wird. Wenn Sie jedoch versuchen, die Migrationen zu verwenden, werden Dienste nicht initialisiert. Daher wird das Überschreiben der Ausnahme fehlschlagen. <p>wenn dies meine entwurfsentscheidung wäre, würde ich wahrscheinlich eher eine option c (modifizierte option a) wählen.</p><h3>erstens, warum nicht 'option b':</h3><p>zum einen gefällt mir die klarheit, dass jedes produkt seinen eigenen tisch hat. wenn es sich nur um eine große tabelle mit einem feld zur bestimmung des typs handelt, ist die beziehung nicht so klar.</p><p>zum anderen würde die indizierungsstrategie immer erfordern, dass dieses typfeld aufgelistet wird. da es sich nur um 4 typen handelt, ist die indexkardinalität extrem niedrig (<code>select * from product\_table where type='x'</code> führt im grunde sowieso einen vollständigen tabellenscan durch)</p><h3>option c.</h3><ul> <li>erstellen sie eine übergeordnete tabelle, die nur die spalten enthält, die alle typen gemeinsam nutzen</li> <li>erstellen sie jeden produkttyp als eigene tabelle mit ihren einzelnen spalten, mit einem zusätzlichen: ein link zur übergeordneten tabelle</li> <li>erstellen sie jede 'link'-tabelle: product\_option, model\_option usw. mit links zu den jeweiligen schlüsseln.</li> <li>für diejenigen mit wechselseitigen links (model\_option, option\_model) erstellen sie auch diese tabellen. dies erhöht die klarheit ihrer joins für alle, die sich das ansehen.</li> </ul><p>der nachteil ist die komplexität, sicherzustellen, dass waisen vermieden werden, wenn dinge aktualisiert/gelöscht werden, und zunächst die abfragen zu entwerfen, die diese tabellen verwenden.</p> hallo,

da ich den eintrag angefangen habe, folgende infos, die ich herausgefunden habe.

folgende daten habe ich eingebeben & jetzt hat’s geklappt:

datum => kaufdatum

stück => anzahl wertpapiere

typ => mögliche kategorie unter depotumsätzen (z.b. einlieferung)

we… Ähm Du sollst eine Wertetabelle machen. D.h. für x Sachen im Bereich von -5 bis 1 einsetzen und dazu die y-Koordinate berechnen. Die Punkte aus x und y Koordinaten dann in ein Koordinatensystem einzeichnen.


Was kannst du daran nicht?