MySQL Query Update funktioniert nicht

[Perlsau]

Zitat von Lemmy:

Zitat von Perlsau:

Die meisten Datenbanken – zumindest alle, die ich schonmal ausprobiert habe – führen beim Update und Insert ein Trim auf Strings (VarChar) durch.

Ich denke du bringst hier gehörig was durcheinander. Ein solches Verhalten eines DBMS (die im übergebenen Daten selbst zu ändern) würde zu sofortigem Deinstallieren und zu einem 10 Jahres Bann (zumindest in meiner Umgebung) führen. Zumindest für Firebird (2.1) und MySQL (5.1) gilt das von dir beschriebene Verhalten nicht.

Hab's gerade eben nochmal getestet:

• In einer Anwendung in einem DBEdit, das auf ein VarChar-Feld verweist, ein Leerzeichen am Ende des Strings angefügt: Leerzeichen bleibt erhalten.
• Im IbExpert in derselben DB im selben Record und derselben Spalte ein Leerzeichen ans Ende des Strings gesetzt: Leerzeichen wird beim Posten entfernt.

Da hab ich also in der Tat was durcheinandergebracht, nehme alles zurück und behaupte das Gegenteil

[Lemmy]

Zitat von Perlsau:

• Im IbExpert in derselben DB im selben Record und derselben Spalte ein Leerzeichen ans Ende des Strings gesetzt: Leerzeichen wird beim Posten entfernt.

Das ist aber ein Problem von IBExpert und nicht von Firebird: Das Leerzeichen wird lediglich in der Gridanzeige entfernt! In der Datenbank bleibt das weiterhin enthalten.
Beispiel: Steht " das " in der Spalte, wird char_length korrekt mit 5 ermittelt, in der Grid-Anzeige fehlt aber das letzte Leerzeichen. Hänge ich nun weitere Leerzeichen per IBExpert-Grid ran, dann bleibt das so bei den 5. Ändere ich das per Update SQL, wird der Text so abgespeichert wie ich will und nicht wie IBExpert meint dass es sein müsste... und es ändert sich auch die String-Länge (Hinweis IBExpert 2015.1.11.1)

[hoika]

Hallo,
wenn mich nicht alles täuscht, ist das Trim eine Konfigurations-Option von IB-Expert.

Heiko

[BadenPower]

Zitat von akio87:

ich habe festgestellt, dass meine alte Update Funktion, siehe 2. Code, in der BDGrid mit einem Leerem String nicht funktioniert. In der neuen Variante, wo ich dachte, das es dort geht, funktioniert der leere String ebenfalls nicht + Update generell nicht, mit folgender Fehlermeldung:
Error: SQL Syntax...

Habt ihr eine Idee?

Für diese Problem habe ich mir spezielle Funktionen geschrieben, welche die Statements automatisch und unabhängig von der jeweils verwendeten Tabelle erstellen.

Die Funktionen berücksichtigen auch, dass in den Komponenten enthaltenen NULL-Wert des Feldes, welcher dann wahlweise als NULL oder als Leerstring übergeben werden kann.

Delphi-Quellcode:

unit uDataModuleDB;

interface

uses
  SysUtils, Classes, Forms, Dialogs, Variants, DB,
  ZConnection, ZAbstractTable, ZDataset, ZAbstractRODataset,
  ZAbstractDataset, ZSqlProcessor, ZSqlMonitor;

type
  TDMDb = class(TDataModule)
  public
    function GenerateZUpdateSQLInsert(ATable: TZTable): String; overload;
    function GenerateZUpdateSQLInsert(ATable: TZTable; ANullAsString: Boolean): String; overload;
    function GenerateZUpdateSQLModify(ATable: TZTable): String; overload;
    function GenerateZUpdateSQLModify(ATable: TZTable; ANullAsString: Boolean): String; overload;
    function GenerateZUpdateSQLDelete(ATable: TZTable): String; overload;
    function GenerateZUpdateSQLDelete(ATable: TZTable; ANullAsString: Boolean): String; overload;
    function GenerateZTableSQLSelectOldValues(ATable: TZTable): String;
    function GenerateZTableSQLSelectCountOldValues(ATable: TZTable): String;
    function GenerateZTableSQLWhereOldValues(ATable: TZTable): String;


  end;

var
  DMDb: TDMDb;

implementation

function TDMDb.GenerateZTableSQLWhereOldValues(ATable: TZTable): string;
var
  liZ1: integer;
  lSQLWhere: String;
begin
  lSQLWhere := '';

  for liZ1 := 0 to ATable.FieldCount - 1 do
   begin
    if (liZ1 > 0) then
     begin
      lSQLWhere := lSQLWhere + ' AND ';
     end;
    lSQLWhere := lSQLWhere + '(';
    if(VarIsNull(ATable.Fields[liZ1].OldValue)) then
     begin
      lSQLWhere := lSQLWhere + '(';
     end;
    lSQLWhere := lSQLWhere + ATable.Fields[liZ1].FieldName + ' = ' + ':OLD_' + ATable.Fields[liZ1].FieldName;
    if(VarIsNull(ATable.Fields[liZ1].OldValue)) then
     begin
      lSQLWhere := lSQLWhere + ')';
      lSQLWhere := lSQLWhere + ' OR (' + ATable.Fields[liZ1].FieldName + ' IS NULL )';
      lSQLWhere := lSQLWhere + ' OR (' + ATable.Fields[liZ1].FieldName + ' = 0 )';
     end;
    lSQLWhere := lSQLWhere + ')';
   end;

  if (lSQLWhere <> '') then
   begin
    lSQLWhere := ' WHERE ' + lSQLWhere;
   end;

  Result := lSQLWhere;
end;

function TDMDb.GenerateZUpdateSQLInsert(ATable: TZTable): string;
begin
  Result := GenerateZUpdateSQLInsert(ATable,true);
end;

function TDMDb.GenerateZUpdateSQLInsert(ATable: TZTable; ANullAsString: boolean): string;
var
  liZ1: integer;
  lSQL: String;
  lSQLFields: String;
  lSQLValues: String;
begin
  lSQLFields := '';
  lSQLValues := '';
  lSQL := 'INSERT INTO ' + ATable.TableName;
  for liZ1 := 0 to ATable.FieldCount - 1 do
   begin
    if (liZ1 > 0) then
     begin
      lSQLFields := lSQLFields + ' , ';
      lSQLValues := lSQLValues + ' , ';
     end;
    lSQLFields := lSQLFields + ATable.Fields[liZ1].FieldName;
    if (     (ANullAsString)
         and (ATable.Fields[liZ1].DataType in [ftString,ftMemo,ftFmtMemo,ftFixedChar,ftWideString,ftFixedWideChar,ftWideMemo])
         and (VarToStr(ATable.Fields[liZ1].Value) = '')
       ) then
     begin
      lSQLValues := lSQLValues + '''' + '''';
     end
    else
     begin
      lSQLValues := lSQLValues + ':' + ATable.Fields[liZ1].FieldName;
     end;
   end;
  lSQL := lSQL + ' (' + lSQLFields + ') VALUES (' + lSQLValues + ')';
  Result := lSQL + ';';

end;

function TDMDb.GenerateZUpdateSQLModify(ATable: TZTable): string;
begin
  Result := GenerateZUpdateSQLModify(ATable,true);
end;

function TDMDb.GenerateZUpdateSQLModify(ATable: TZTable; ANullAsString: boolean): string;
var
  liZ1: integer;
  lSQL: String;
  lSQLWhere: String;
begin

  lSQL := 'UPDATE ' + ATable.TableName + ' SET ';
  for liZ1 := 0 to ATable.FieldCount - 1 do
   begin
    if (liZ1 > 0) then
     begin
      lSQL := lSQL + ' , ';
     end;

    lSQL := lSQL + ATable.Fields[liZ1].FieldName + ' = ';
    if (     (ANullAsString)
         and (ATable.Fields[liZ1].DataType in [ftString,ftMemo,ftFmtMemo,ftFixedChar,ftWideString,ftFixedWideChar,ftWideMemo])
         and (VarToStr(ATable.Fields[liZ1].Value) = '')
       ) then
     begin
      lSQL := lSQL + '''' + '''';
     end
    else
     begin
      lSQL := lSQL + ':' + ATable.Fields[liZ1].FieldName;
     end;

   end;
  lSQLWhere := GenerateZTableSQLWhereOldValues(ATable);
  Result := lSQL + lSQLWhere + ';';

end;

function TDMDb.GenerateZUpdateSQLDelete(ATable: TZTable): string;
begin
  Result := GenerateZUpdateSQLDelete(ATable,true);
end;

function TDMDb.GenerateZUpdateSQLDelete(ATable: TZTable; ANullAsString: boolean): string;
var
  lSQL: String;
  lSQLWhere: String;
begin
  lSQL := 'DELETE FROM ' + ATable.TableName;
  lSQLWhere := GenerateZTableSQLWhereOldValues(ATable);
  Result := lSQL + lSQLWhere + ';';
end;

end;

Der Aufruf und das Generieren der Statements erfolgt dann in der Update-Komponente in den jeweiligen Events OnBeforeDelete, OnBeforeInsert und OnBeforeModify:

Delphi-Quellcode:

procedure TF_Data.ZUPS_TableBeforeDeleteSQL(Sender: TObject);
begin
  ZUPS_Table.DeleteSQL.Text := DMDb.GenerateZUpdateSQLDelete(ZT_Table);
end;

procedure TF_Data.ZUPS_TableBeforeInsertSQL(Sender: TObject);
begin
  ZUPS_Table.InsertSQL.Text := DMDb.GenerateZUpdateSQLInsert(ZT_Table);
end;

procedure TF_Data.ZUPS_TableBeforeModifySQL(Sender: TObject);
begin
  ZUPS_Table.ModifySQL.Text := DMDb.GenerateZUpdateSQLModify(ZT_Table);
end;

Ich hoffe das hilft Dir weiter.

[Dejan Vu]

Sehr schön, das Du die 'hässliche' Generierung der SQL-Befehle so versteckst. Das schafft Übersicht.

Zwei Anmerkungen:
1. Wieso deklarierst du nicht einfach ein Feld als 'PK', dann kannst Du dir das 'WhereOldValues' sparen?
2. Deine NULL-Behandlung sieht (auf den ersten Blick beim Frühstück) etwas wackelig aus. Du behandelst '0' als NULL-Äquivalent, aber den leeren String nicht?

[BadenPower]

Zitat von Dejan Vu:

Sehr schön, das Du die 'hässliche' Generierung der SQL-Befehle so versteckst. Das schafft Übersicht.

Wieso verstecken?
Das sind Grundfunktionen und für jede Tabelle ausführbar und gehören daher zur Übersichtlichkeit des Quellcodes in separate Funktionen.

Zitat von Dejan Vu:

1. Wieso deklarierst du nicht einfach ein Feld als 'PK', dann kannst Du dir das 'WhereOldValues' sparen?

Man sollte etwas über den Tellerrand hinausschauen und dann würde man feststellen, dass ein PK nicht das leistet, was die Generierung dieses SQL-Statements leistet.

Durch das SQL-Statement ist gewährleistet, dass der Datensatz nur geändert wird, wenn zwischenzeitlich keine Änderungen des Datensatzes durch z.B einen anderen User durchgeführt wurden.

Der PK "erkennt" dies ja nicht.

Zitat von Dejan Vu:

2. Deine NULL-Behandlung sieht (auf den ersten Blick beim Frühstück) etwas wackelig aus. Du behandelst '0' als NULL-Äquivalent, aber den leeren String nicht?

Weil dies nicht notwendig ist.

[Sir Rufo]

Um Concurrent Conflicts zu erkennen würde auch ein Feld mit der RowVersion reichen.

[BadenPower]

Zitat von Sir Rufo:

Um Concurrent Conflicts zu erkennen würde auch ein Feld mit der RowVersion reichen.

Wenn Du die Datenbank-Struktur in der eigenen Hand hast, dann ja.

Weitere Vorraussetzung wäre dann auch noch, dass nur Deine Software auf die Datenbank zugreift, oder dass auch alle anderen Entwicklungen, welche auf die Tabelle zugreifen, dieses Feld beschreiben.