<\/p>\n
Wir haben bereits in mehreren Beiträgen beschrieben, wie Sie die individuelle Reihenfolge von Elementen einer Tabelle über den Inhalt eines Feldes etwa namens „ReihenfolgeID“ einstellen können – zum Beispiel in Listenfeldern oder Unterformularen in der Datenblattansicht. Dort haben wir die Reihenfolge dann durch Markieren der Einträge und anschließendes Betätigen etwa von Schaltflächen mit Beschriftungen wie „Ganz nach oben“, „Nach oben“, „Nach unten“ oder „Ganz nach unten“ geändert. Im vorliegenden Beitrag schauen wir uns nun an, wie wir im Listenfeld die Reihenfolge für mehrere Einträge gleichzeitig ändern können.<\/b><\/p>\nMehrfach-Reihenfolge im Listenfeld<\/h2>\n
Listenfelder haben gegenüber der Datenblattansicht den großen Vorteil, dass Sie damit nicht nur zusammenhängende Einträge markieren können, sondern sogar Einträge, die beliebig im Listenfeld verteilt sind. Die einzige Voraussetzung dafür ist, dass Sie für die Eigenschaft Mehrfachauswahl <\/b>des Listenfeldes den Wert Einzeln <\/b>oder Erweitert <\/b>auswählen. Welchen Sie nutzen, hängt von den Anforderungen und den Gewohnheiten der Benutzer ab – für die hier vorgestellte Lösung funktionieren beide gleich gut.<\/p>\nEntwurf des Beispielformulars<\/h2>\n
Das Beispielformular bauen wir wie in Bild 1 auf. Wir fügen ein Listenfeld namens lstKategorien <\/b>ein sowie vier Schaltflächen namens cmdTop<\/b>, cmdUp<\/b>, cmdDown <\/b>und cmdBottom<\/b>.<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_04\/pic_1197_001.png\")
<\/p>\n
Bild 1: Entwurf des Formulars frmMehrreihenfolgeListBox<\/span><\/b><\/p>\n Außerdem hinterlegen wir als Datensatzherkunft <\/b>für das Listenfeld die Tabelle tblKategorien<\/b>, deren Entwurf wie in Bild 2 aussieht. Genau genommen verwenden wir sogar eine Abfrage auf Basis dieser Tabelle, welche die Datensätze nach dem Feld ReihenfolgeID<\/b> sortiert:<\/p>\n Bild 2: Entwurf der Tabelle tblKategorien<\/span><\/b><\/p>\n Die Eigenschaft Spaltenanzahl <\/b>des Listenfeldes stellen wir auf 3 <\/b>ein, die Eigenschaft Spaltenbreiten <\/b>auf 0cm;5cm<\/b>. Dadurch erscheinen nur das zweite und das dritte Feld der Datensatzherkunft im Listenfeld, also die Felder Kategoriename <\/b>und ReihenfolgeID<\/b>.<\/p>\n Bevor wir uns an die Programmierung begeben, müssen wir noch herausfinden, wie die Reihenfolge überhaupt geändert werden soll. Bei einem einzelnen Element, dessen Reihenfolge verschoben werden soll, ist das kein Problem: Hier ermitteln wir die ReihenfolgeID<\/b> des zu verschiebenden Elements und den des Zielelements und nehmen entsprechende Änderungen an den Inhalten dieses Felds für die betroffenen Datensätze vor.<\/p>\n Bei mehreren gleichzeitig zu verschiebenden Datensätzen, die darüberhinaus noch nicht einmal zusammenhängen müssen, ist allerdings zuvor zu definieren, welcher Datensatz wo landet. Wenn Sie beispielsweise den zweiten und den dritten Eintrag markieren und die Schaltfläche Ganz nach oben <\/b>betätigen, ist die Aufgabe klar: Dann sollen der zweite und der dritte Datensatz die erste und die zweite Position einnehmen und der erste auf die dritte Position verschoben werden:<\/p>\n Gleiches gilt, wenn diese beiden Datensätze etwa mit der Schaltfläche Nach unten <\/b>um eine Position nach unten verschoben werden sollen: Dann landen der zweite und der dritte Eintrag auf der dritten und vierten Position und der vierte Eintrag wird nach oben auf die zweite Position verschoben:<\/p>\n Was aber, wenn der Benutzer etwa den zweiten und den vierten Eintrag verschiebt Dann gibt es zwei Möglichkeiten:<\/p>\n Beides lässt sich wieder besser am Beispiel erläutern. Angenommen, wir wollen den zweiten und den vierten Eintrag nach der ersten Methode um eine Position nach oben verschieben, sieht das so aus:<\/p>\n Die Einträge werden also nach oben verschoben, behalten aber die Abstände zueinander bei. Oder wir verschieben einfach alle markierten Elemente an die Zielposition und alle verdrängten Elemente nach unten:<\/p>\n Da die zweite Methode einfacher zu programmieren ist, werden wir diese verwenden. Auch, weil uns kein Anwendungsfall einfällt, bei dem man nach der erstgenannten Methode verfahren sollte.<\/p>\n Im Klassenmodul des Formulars legen wir zunächst drei Konstanten an, die wichtige Daten aufnehmen, die an vielen Stellen verwendet werden – zum Beispiel den Namen der Quelltabelle, des Primärschlüsselfeldes dieser Tabelle und des Reihenfolge-Feldes.<\/p>\n Auf diese Weise brauchen Sie diese Bezeichnungen nur an einer Stelle zu ändern, wenn Sie die Reihenfolge-Funktionen einmal in ein anderes Formular übernehmen wollen:<\/p>\n Außerdem deklarieren wir eine Variable namens m_ListBox<\/b>, in der wie einen Verweis auf das Listenfeld speichern, das die Datensätze in der Reihenfolge anzeigen soll:<\/p>\n Diese Variable füllen wir gleich beim Laden des Formulars in der folgenden Prozedur mit einem Verweis auf das gewünschte Listenfeld:<\/p>\n Hier rufen wir auch gleich die Prozedur FillOrderID <\/b>auf. Diese sorgt dafür, dass die Werte des Feldes ReihenfolgeID <\/b>aktualisiert werden, so dass diese durchnummeriert sind.<\/p>\n Die Prozedur FillOrder <\/b>sieht wie in Listing 1 aus. Diese Prozedur greift die Inhalte der Konstanten m_PKField<\/b>, m_Orderfield <\/b>und m_Table <\/b>auf und stellt damit ein Recordset zusammen, das die Datensätze der angegebenen Tabelle, hier tblKategorien<\/b>, mit den interessanten Feldern KategorieID <\/b>und ReihenfolgeID <\/b>enthält. Dieses Recordset durchläuft die Prozedur in einer Do While<\/b>-Schleife und aktualisiert dort den Wert des Feldes aus m_Orderfield<\/b>, hier ReihenfolgeID<\/b>, mit dem Wert der Eigenschaft AbsolutePosition <\/b>des Recordsets und addiert noch den Wert 1 <\/b>hinzu. Dadurch werden die Datensätze der Tabelle mit Werten für das Feld ReihenfolgeID <\/b>durchnummeriert.<\/p>\n Listing 1: Prozedur zum Wiederherstellen der Werte des Feldes ReihenfolgeID<\/span><\/b><\/p>\n Das Ergebnis sieht dann wie in Bild 3 aus.<\/p>\n Bild 3: Die Tabelle tblKategorien mit Werten im Feld ReihenfolgeID<\/span><\/b><\/p>\n Die vier Schaltflächen versehen wir mit jeweils einer Prozedur, welche die Reihenfolge der aktuell markierten Einträge aktualisiert. Die Prozedur für die oberste Schaltfläche cmdTop <\/b>lautet wie folgt:<\/p>\n Hier rufen wir als Erstes die Funktion GetMove <\/b>auf. Diese ist dafür verantwortlich, ein Array zusammenzustellen, dass alle Primärschlüsselwerte der zu verschiebenden Einträge des Listenfeldes aufnimmt (siehe Listing 2). Die Funktion durchläuft dazu eine For Each<\/b>-Schleife über alle ausgewählten Elemente des Listenfeldes (ItemsSelected<\/b>), das wir mit m_ListBox <\/b>referenziert haben. Der 0-basierte Index des jeweils durchlaufenen Elements wird in der Variablen var <\/b>gespeichert. Darin wird zuerst das Array lngMove <\/b>auf eine Anzahl von Einträgen entsprechend dem Wert der Variablen i <\/b>erweitert. Dann weisen wir dem Element mit dem Index i<\/b> den Wert der ersten Spalte des Listenfeldes zu (ItemData(var)<\/b>). Schließlich erhöhen wir den Wert der Variablen i <\/b>um eins, bevor wir den nächsten ausgewählten Eintrag untersuchen.<\/p>\n Listing 2: Die Prozedur GetMove<\/span><\/b><\/p>\n Die nächste Anweisung ermittelt mit der DMin<\/b>-Funktion den kleinsten Wert des Feldes aus m_Orderfield <\/b>(hier ReihenfolgeID<\/b>) der Tabelle aus m_Table <\/b>(hier tblKategorien<\/b>) und speichert diesen in der Variablen lngTarget<\/b>. Das ist in diesem Fall das Ziel beim Verschieben des Elements. Danach folgt der Aufruf der Prozedur InterchangeOrder <\/b>mit lngTarget <\/b>und dem Array lngMove <\/b>als Parameter. Diese schauen wir uns weiter unten an. Die Prozedur stellt die ReihenfolgeID<\/b>-Werte für die betroffenen Elemente neu ein.<\/p>\n Schließlich ruft die Prozedur noch eine weitere Routine namens RequeryControls <\/b>auf. Diese aktualisiert zuerst den Inhalt des Listenfeldes, wodurch die Elemente nach dem Ändern der Werte des Feldes ReihenfolgeID <\/b>durch die vorgegebene Sortierung gegebenenfalls neu angeordnet werden. Dann ruft sie die Prozedur SelectEntries<\/b> auf, die dafür sorgt, dass die vor dem Verschieben markierten Einträge erneut markiert werden. Durch das Requery<\/b> gehen die Markierungen nämlich verloren. Schließlich sorgt die Prozedur ActivateControls <\/b>dafür, dass die Schaltflächen entsprechend der aktuell ausgewählten Elemente aktiviert oder deaktiviert werden. Wenn nämlich das erste Element markiert ist, sollen die Schaltflächen Ganz nach oben <\/b>und Nach oben <\/b>deaktiviert werden. Wenn das letzte Element markiert ist, sollen die Schaltflächen Nach unten <\/b>und Ganz nach unten <\/b>deaktiviert sein:<\/p>\n Bevor wir uns die hier erwähnten Prozeduren ansehen, werfen wir noch einen Blick auf den Code der übrigen Schaltflächen. Zunächst die Schaltfläche, mit der die aktuell markierten Einträge um eine Position nach oben verschoben werden sollen:<\/p>\n <\/p>\n Der Unterschied ist, dass wir den Wert für lngTarget<\/b>, also für die Zielposition, auf etwas aufwendigere Weise ermitteln, und zwar mit zwei Domänenfunktionen. Die erste DLookup<\/b>-Funktion ermittelt den Wert des Feldes ReihenfolgeID <\/b>für den Datensatz der Tabelle tblKategorien<\/b>, der dem ersten markierten Datensatz entspricht. Wenn also die Datensätze mit den Primärschlüsselwerten 2 <\/b>und 3 <\/b>markiert sind, die in diesem Fall auch die Positionen 2 <\/b>und 3 <\/b>innehaben, dann ist der mit dem Primärschlüsselwert 2 <\/b>der aus lngMove(0)<\/b>, also der erste Wert des Arrays. Für diesen ermittelt die DLookup<\/b>-Funktion dann den Wert des Feldes ReihenfolgeID<\/b>, hier auch 2<\/b>, und schreibt ihn in die Variable lngTargetMove<\/b>. Die folgende DMax<\/b>-Funktion ermittelt dann den größten Wert des Feldes ReihenfolgeID<\/b>, der kleiner als der Wert aus lngTargetMove <\/b>ist. Damit ist dann die Ziel-Reihenfolgenposition ermittelt und in der Variablen lngTarget <\/b>gespeichert. Mit lngTarget <\/b>und lngMove() <\/b>wird dann wiederum die Prozedur InterchangeOrder <\/b>aufgerufen und dann die Prozedur RequeryControls<\/b>.<\/p>\n Die durch diese Schaltfläche ausgelöste Prozedur ist wieder genauso einfach wie die für die Schaltfläche Ganz nach oben<\/b>. Hier verwenden wir lediglich für die Variable lngTarget <\/b>den maximalen Wert des Feldes ReihenfolgeID <\/b>der Tabelle tblKategorien<\/b>:<\/p>\n Etwas komplizierter ist dagegen die Schaltfläche mit der Beschriftung Nach unten<\/b> (siehe Listing 3). Hier ermitteln wir wieder das Array mit den Primärschlüsselwerten der markierten Elemente. Daraus berechnen wir dann über die Funktion UBound <\/b>den größten Index-Wert und speichern ihn in lngMax<\/b>. Diesen nutzen wir dann in einer DLookup<\/b>-Funktion als Vergleichswert für das Kriterium, mit der wir den ReihenfolgeID<\/b>-Wert für den untersten markierten Eintrag ermitteln. Die folgende DMin<\/b>-Funktion liest dann den kleinsten ReihenfolgeID<\/b>-Wert der Tabelle tblKategorien <\/b>ein, der größer ist als der ReihenfolgeID<\/b>-Wert aus lngTargetMove<\/b>. Der Rest entspricht der Vorgehensweise der vorherigen Prozeduren.<\/p>\n Listing 3: Prozedur zum Verschieben der markierten Einträge nach unten<\/span><\/b><\/p>\n Diese Prozedur erwartet die ReihenfolgeID <\/b>für das Element, vor oder hinter dem die zu verschiebenden Elemente landen sollen (lngTargetOrderID<\/b>) und das Array mit den Primärschlüsselwerten der zu verschiebenden Elemente als Parameter. Ob die Elemente vor oder hinter das Zielelement verschoben werden, hängt von der Richtung ab: Wenn die Elemente nach oben verschoben werden, landen Sie vor dem Zielelement, wenn Sie nach unten verschoben werden, hinter dem Zielelement. Die Prozedur durchläuft im ersten Teil (siehe Listing 4) zuerst eine For…Next<\/b>-Schleife, in der die einzelnen Elemente aus dem Array lngMove <\/b>zu einer kommaseparierten Liste zusammengefügt werden. Anschließend sieht der Inhalt etwa so aus:<\/p>\n Listing 4: Prozedur zum Vertauschen der Reihenfolge, Teil 1<\/span><\/b><\/p>\n Von dieser Zeichenkette trennt die folgende Mid<\/b>-Funktion die ersten beiden Zeichen ab, also das Komma und das Leerzeichen. Die folgende Prozedur fügt dann vorn die IN<\/b>-Klausel an und fasst die Liste der Primärschlüsselwerte in runde Klammern ein. Das Ergebnis sieht dann etwa so aus:<\/p>\n Danach ermitteln wir per DLookup <\/b>den ReihenfolgeID<\/b>-Wert für das erste markierte Element aus dem Array lngMove<\/b> und speichern es in der Variablen lngTargetMove<\/b>. Ist der Parameter lngTargetOrderID<\/b>, der die ReihenfolgeID <\/b>mit dem Ziel des Verschiebens angibt, kleiner als lngTargetMove<\/b>, dann soll das Verschieben offensichtlich nach oben erfolgen. In diesem Fall kommt der erste Teil der nachfolgenden If…Then<\/b>-Bedingung zum Einsatz, anderenfalls der Else<\/b>-Teil. Im If<\/b>-Teil stellen wir eine SQL-Abfrage zum Ermitteln der zu verschiebenden Elemente zusammen. Wenn wir etwa die Elemente mit den Primärschlüsselwerten 4<\/b>, 6 <\/b>und 8 <\/b>um eine Position nach oben verschieben wollen, resultiert das in der folgenden SQL-Abfrage:<\/p>\n Auf Basis dieser Abfrage erstellt die Prozedur dann ein Recordset namens rstVerschieben<\/b>. Vor dem Ausführen der Do While<\/b>-Schleife über alle Datensätze des Recordsets tragen wir den Wert aus lngTargetOrderID <\/b>in die Zählervariable j <\/b>ein. Danach beginnen wir in der Schleife mit dem Anpassen zunächst der ReihenfolgeID<\/b>-Werte der zu verschiebenden Datensätze. Dazu versetzen wir den aktuellen Datensatz mit der Edit<\/b>-Methode in den Bearbeiten-Zustand. Dann stellen wir den Wert des Feldes aus m_Orderfield<\/b>, hier ReihenfolgeID<\/b>, auf den Wert aus der Variablen j <\/b>ein. Für den ersten Datensatz, der im Beispiel den Wert 4 <\/b>für das Feld ReihenfolgeID <\/b>aufweist, erhält dieses Feld nun den Wert 3<\/b>. Nach dem Speichern der Änderungen erhält der Datensatz mit dem Wert 6 <\/b>im Feld ReihenfolgeID <\/b>den Wert 4<\/b>, also j + 1<\/b>. Nach dem Einstellen der ReihenfolgeID<\/b>-Werte für die zu verschiebenden Einträge müssen natürlich noch die für die übrigen Einträge angepasst werden. Diese Datensätze ermitteln wir mit einer zweiten SQL-Abfrage, die nach dem Zusammensetzen für unser Beispiel wie folgt aussieht:<\/p>\n Hier suchen wir also nach allen Datensätzen, die nicht zu den zu verschiebenden Datensätzen gehören (NOT IN (4, 6, 8)<\/b>) und deren ReihenfolgeID<\/b>-Wert größer oder gleich 3 <\/b>ist – wir schließen also die Datensätze aus, die ohnehin vor dem Ziel des Verschiebevorgangs liegen und die nicht angepasst werden müssen. Diese Datensätze landen in einem Recordset namens rstVerdraengen<\/b>.<\/p>\n Für diese Datensätze vergeben wir über die Zählervariable j<\/b>, die wir weiter mit jedem Datensatz um eins erhöhen, die neuen Werte für das Feld ReihenfolgeID<\/b>.<\/p>\n Im Else<\/b>-Teil der Prozedur, den Sie in Listing 5 finden, ermitteln wir für die Variable lngStartVerschieben <\/b>den Wert des Feldes ReihenfolgeID <\/b>für das erste zu verschiebende Element aus dem Array lngMove<\/b>.<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_04\/pic_1197_002.png\")
<\/p>\nSELECT tblKategorien.KategorieID, tblKategorien.Kategoriename, tblKategorien.ReihenfolgeID FROM tblKategorien ORDER BY tblKategorien.ReihenfolgeID;<\/pre>\n
Definition des Änderns der Reihenfolge<\/h2>\n
Vorher: Nachher:\r\nEintrag 1 Eintrag 2\r\nEintrag 2 Eintrag 3\r\nEintrag 3 Eintrag 1\r\n... ...<\/pre>\n
Vorher: Nachher:\r\nEintrag 1 Eintrag 1\r\nEintrag 2 Eintrag 4\r\nEintrag 3 Eintrag 2\r\nEintrag 4 Eintrag 3\r\n... ...<\/pre>\n
\n
Vorher: Nachher:\r\nEintrag 1 Eintrag 2\r\nEintrag 2 Eintrag 1\r\nEintrag 3 Eintrag 4\r\nEintrag 4 Eintrag 3<\/pre>\n
Vorher: Nachher:\r\nEintrag 1 Eintrag 2\r\nEintrag 2 Eintrag 4\r\nEintrag 3 Eintrag 1\r\nEintrag 4 Eintrag 3<\/pre>\n
Code für Formular und Listenfeld<\/h2>\n
Const m_Table As String<\/span> = \"tblKategorien\"\r\nConst m_PKField As String<\/span> = \"KategorieID\"\r\nConst m_Orderfield As String<\/span> = \"ReihenfolgeID\"<\/pre>\nDim <\/span>m_ListBox As <\/span>ListBox<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> m_ListBox = Me!lstKategorien\r\n FillOrderID\r\nEnd Sub<\/span><\/pre>\nReihenfolgeID aktualisieren<\/h2>\n
Public Sub <\/span>FillOrderID()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CodeDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT \" & m_PKField & \", \" & m_Orderfield & \" FROM \" & m_Table & \" ORDER BY \" _\r\n & m_Orderfield, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n rst.Edit\r\n rst(m_Orderfield) = rst.AbsolutePosition + 1\r\n rst.Update\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_04\/pic_1197_003.png\")
<\/p>\nSchaltflächen mit Code versehen<\/h2>\n
Private Sub <\/span>cmdTop_Click()\r\n Dim <\/span>lngTarget As Long<\/span>\r\n Dim <\/span>lngMove() As Long<\/span>\r\n lngMove = GetMove\r\n lngTarget = DMin(m_Orderfield, m_Table)\r\n InterchangeOrder lngTarget, lngMove\r\n RequeryControls lngMove\r\nEnd Sub<\/span> <\/pre>\nPrivate Function <\/span>GetMove() As Long<\/span>()\r\n Dim <\/span>lngMove() As Long<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>var As Variant<\/span>\r\n For Each var In m_ListBox.ItemsSelected\r\n ReDim Preserve lngMove(i)\r\n lngMove(i) = m_ListBox.ItemData(var)\r\n i = i + 1\r\n Next<\/span> var\r\n GetMove = lngMove\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>RequeryControls(lngMove() As Long<\/span>)\r\n m_ListBox.Requery\r\n SelectEntries lngMove()\r\n ActivateControls\r\nEnd Sub<\/span><\/pre>\nSchaltfläche „Nach oben“<\/h2>\n
Private Sub <\/span>cmdUp_Click()\r\n Dim <\/span>lngTarget As Long<\/span>, lngTargetMove As Long<\/span>\r\n Dim <\/span>lngMove() As Long<\/span>\r\n lngMove = GetMove\r\n lngTargetMove = DLookup(m_Orderfield, m_Table, _\r\n m_PKField & \"=\" & lngMove(0))\r\n lngTarget = DMax(m_Orderfield, m_Table, m_Orderfield _\r\n & \"<\" & lngTargetMove)\r\n InterchangeOrder lngTarget, lngMove\r\n RequeryControls lngMove\r\nEnd Sub<\/span><\/pre>\nSchaltfläche „Ganz nach unten“<\/h2>\n
Private Sub <\/span>cmdBottom_Click()\r\n Dim <\/span>lngTarget As Long<\/span>\r\n Dim <\/span>lngMove() As Long<\/span>\r\n lngMove = GetMove\r\n lngTarget = DMax(m_Orderfield, m_Table)\r\n InterchangeOrder lngTarget, lngMove\r\n RequeryControls lngMove\r\nEnd Sub<\/span><\/pre>\nSchaltfläche „Nach unten“<\/h2>\n
Private Sub <\/span>cmdDown_Click()\r\n Dim <\/span>lngTarget As Long<\/span>\r\n Dim <\/span>lngMove() As Long<\/span>\r\n Dim <\/span>lngTargetMove As Long<\/span>\r\n Dim <\/span>lngMax As Long<\/span>\r\n lngMove = GetMove\r\n lngMax = UBound<\/span>(lngMove)\r\n lngTargetMove = DLookup(m_Orderfield, m_Table, m_PKField & \"=\" & lngMove(lngMax))\r\n lngTarget = DMin(m_Orderfield, m_Table, m_Orderfield & \">\" & lngTargetMove)\r\n InterchangeOrder lngTarget, lngMove\r\n RequeryControls lngMove\r\nEnd Sub<\/span><\/pre>\nReihenfolge vertauschen<\/h2>\n
Public Sub <\/span>InterchangeOrder(lngTargetOrderID As Long<\/span>, lngMove() As Long<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstVerschieben As <\/span>DAO.Recordset\r\n Dim <\/span>rstVerdraengen As <\/span>DAO.Recordset\r\n Dim <\/span>strVerschieben As String<\/span>\r\n Dim <\/span>strVerdraengen As String<\/span>\r\n Dim <\/span>lngTargetMove As Long<\/span>\r\n Dim <\/span>strIn As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Dim <\/span>lngStartVerschieben As Long<\/span>\r\n Set<\/span> db = CodeDb\r\n For i = LBound<\/span>(lngMove) To UBound<\/span>(lngMove)\r\n strIn = strIn & \", \" & lngMove(i)\r\n Next<\/span> i\r\n strIn = Mid<\/span>(strIn, 3)\r\n strIn = \" IN (\" & strIn & \")\"\r\n lngTargetMove = DLookup(m_Orderfield, m_Table, m_PKField & \" = \" & lngMove(0))\r\n If <\/span>lngTargetOrderID < lngTargetMove Then<\/span>\r\n strVerschieben = \"SELECT \" & m_PKField & \", \" & m_Orderfield & \" FROM \" & m_Table & \" WHERE \" & m_PKField _\r\n & strIn & \" ORDER BY \" & m_Orderfield\r\n Set<\/span> rstVerschieben = db.OpenRecordset(strVerschieben, dbOpenDynaset)\r\n j = lngTargetOrderID\r\n Do While<\/span> Not<\/span> rstVerschieben.EOF\r\n rstVerschieben.Edit\r\n rstVerschieben(m_Orderfield) = j\r\n rstVerschieben.Update\r\n rstVerschieben.MoveNext<\/span>\r\n j = j + 1\r\n Loop<\/span>\r\n strVerdraengen = \"SELECT \" & m_PKField & \", \" & m_Orderfield & \" FROM \" & m_Table _\r\n & \" WHERE \" & m_PKField _\r\n & \" NOT\" & strIn & \" AND \" & m_Orderfield & \" >= \" & lngTargetOrderID & \" ORDER BY \" & m_Orderfield\r\n Set<\/span> rstVerdraengen = db.OpenRecordset(strVerdraengen, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstVerdraengen.EOF\r\n rstVerdraengen.Edit\r\n rstVerdraengen(m_Orderfield) = j\r\n rstVerdraengen.Update\r\n rstVerdraengen.MoveNext<\/span>\r\n j = j + 1\r\n Loop<\/span>\r\n ...<\/pre>\n, 1, 2, 3<\/pre>\n
IN (1, 2, 3)<\/pre>\n
SELECT * FROM tblKategorien WHERE KategorieID IN (4, 6, 8) ORDER BY ReihenfolgeID<\/pre>\n
SELECT * FROM tblKategorien WHERE KategorieID \r\nNOT IN (4, 6, 8) \r\nAND ReihenfolgeID >= 3 ORDER BY ReihenfolgeID<\/pre>\n
Else-Teil der Prozedur InterchangeOrder<\/h2>\n
...\r\n Else<\/span>\r\n lngStartVerschieben = DLookup(m_Orderfield, m_Table, m_PKField & \"=\" & lngMove(0))\r\n strVerdraengen = \"SELECT \" & m_PKField & \", \" & m_Orderfield & \" FROM \" & m_Table _\r\n & \" WHERE \" & m_PKField _\r\n & \" NOT\" & strIn & \" AND \" & m_Orderfield & \" > \" & lngStartVerschieben _\r\n & \" AND \" & m_Orderfield & \" <= \" _\r\n & lngTargetOrderID & \" ORDER BY \" & m_Orderfield\r\n Set<\/span> rstVerdraengen = db.OpenRecordset(strVerdraengen, dbOpenDynaset)\r\n j = DLookup(m_Orderfield, m_Table, m_PKField & \"=\" & lngMove(0))\r\n