Wie einen array of Integer speichern?

[Benedikt1983]

Hallo zusammen!

Hat jemand eine Idee, wie man am besten einen (dynamischen) array of Integer in einer Datenbank speichert? Brauch ich ein BLOB oder geht's auch ander?

Vielen Dank!

[Flips]

Hi.

Kenne mich mit Datenbanken außer MySQL jetzt nicht so gut aus, aber warum machst du das Array nicht einfach zu nem einzigen String, getrennt mit Seperators.
Also auf dem Array

Delphi-Quellcode:

zahlen[0] := 1;
zahlen[1] := 5;
zahlen[2] := 9;
zahlen[3] := 32;

wird beispielsweise

Code:

1;5;9;32

Kennst vielleicht die implode/explode Funktion in PHP.
Implode macht aus nem Array so eine Kette, explode splitet sie wieder in ein Array.
Implode könntest du dir wohl einfach selber machen, explode hab ich mal nachgeschaut und diesen Code gefunden:

Delphi-Quellcode:

function Explode(const Separator, S: string; Limit: Integer = 0):
  TStringDynArray;
var
  SepLen       : Integer;
  F, P         : PChar;
  ALen, Index  : Integer;
begin
  SetLength(Result, 0);
  if (S = '') or (Limit < 0) then
    Exit;
  if Separator = '' then
  begin
    SetLength(Result, 1);
    Result[0] := S;
    Exit;
  end;
  SepLen := Length(Separator);
  ALen := Limit;
  SetLength(Result, ALen);

  Index := 0;
  P := PChar(S);
  while P^ <> #0 do
  begin
    F := P;
    P := StrPos(P, PChar(Separator));
    if (P = nil) or ((Limit > 0) and (Index = Limit - 1)) then
      P := StrEnd(F);
    if Index >= ALen then
    begin
      Inc(ALen, 5); // mehrere auf einmal um schneller arbeiten zu können
      SetLength(Result, ALen);
    end;
    SetString(Result[Index], F, P - F);
    Inc(Index);
    if P^ <> #0 then
      Inc(P, SepLen);
  end;
  if Index < ALen then
    SetLength(Result, Index); // wirkliche Länge festlegen
end;

Hier gegoogelt

So würde ichs machen :wink: :coder:

[Die Muhkuh]

Hier ist noch Explode und Implode

[himitsu]

und wenn du es als binärdaten speicherst?

V = Array of Integer

Size = Length(V) * SizeOf(Integer)
Data = Pointer(V)

[Benedikt1983]

Ok, vielen Dank, das mit dem String und implode/explode hatte ich mit schon gedacht und werde auch nehmen, die Pointervariante verstehe ich leider nicht genau... Trotzdem vielen Dank!

[SirThornberry]

wenn du die Integers aber als String speicherst, verbrauchst du in der Regel mehr platz (außer du hast kleine Zahlen).
Denn:
50000,66999
ergibt 11 Byte
das ganze als Integer = 2 * SizeOf(Integer) = 8 Byte

[himitsu]

V ist einfach mal ein Array of Integer. (irgendeinen Namen mußte ich ja nehmen)
Außerdem kenn ich mich mit Datenbanken nicht auß, aber viele besitzen Möglichkeiten um Binärdaten zu speichern ... also brauchst du nur x Bytes {die Anzahl errechnet und in "Size" gespeichert} von der Position y {in diesem Fall Pointer(V) } in deer Datenbank abzuspeichern

Delphi-Quellcode:

//speichern
SaveToDB('meinArray', Pointer(V), Length(V) * SizeOf(Integer));

//laden
SetLength(V, GetDataSize('meinArray') div SizeOf(Integer));
LoadFromDB('meinArray', Pointer(V), Length(V) div SizeOf(Integer));

Keine Ahnung wie das bei dir heißt, aber irgendwas, wo man die Daten speichern/auslesen kann wirds schon geben ._.

Delphi-Quellcode:

//Procedure SaveToDB(Name: String; P: Pointer; Size: Integer);
//Function GetDataSize(Name: String): Integer;
//Procedure LoadFromDB(Name: String; P: Pointer; Size: Integer);

[jim_raynor]

Mit Pointer(V) wirst du bei einem Dynamischen Array keinen Erfolg haben, da an der Adresse V nur ein weiterer Zeiger auf die steht. Hier musst du dir die Adresse des ersten Elemtentes zurückgeben:

Delphi-Quellcode:

//speichern 
SaveToDB('meinArray', Addr(V[0]), Length(V) * SizeOf(Integer)); 

//laden 
SetLength(V, GetDataSize('meinArray') div SizeOf(Integer)); 
LoadFromDB('meinArray', Addr(V[0]), Length(V) * SizeOf(Integer));

P.S: beim Laden hast / SizeOf(Integer) geschrieben ;)

[GuenterS]

Zitat:

Zitat von SirThornberry

wenn du die Integers aber als String speicherst, verbrauchst du in der Regel mehr platz (außer du hast kleine Zahlen).
Denn:
50000,66999
ergibt 11 Byte
das ganze als Integer = 2 * SizeOf(Integer) = 8 Byte

:gruebel: Da hast Du recht, aber... die Ausgangsfrage bleibt doch? Wie würdest Du das in einer Datenbank speichern?

Zumal ja Anzahl der Integers nach oben offen ist.

[edit]
Hm wohl so wie himitsu schrieb
[/edit]

[himitsu]

Zitat:

Zitat von jim_raynor

Mit Pointer(V) wirst du bei einem Dynamischen Array keinen Erfolg haben, da an der Adresse V nur ein weiterer Zeiger auf die steht.

Addr(V[0]) oder @V[0] oder Pointer(V) sind im Grunde das "Gleiche",
denn in einem dynamschen Array ist zwar die Variable ein Zeiger auf die Datenstruktur, allerdings zeigt der nicht auf den Anfang der Datenstruktur, sondern auf das erste Element im Array, außerdem ist dieser Wert gleich NIL, wenn 0 das Array eine Länge von 0 hat.
Also bei Length(V)=0 ist Pointer(V) = nil, wärend aber V[0], @V[0] und Addr(V[0]) eine nette Zugriffsverletzung ergibt :zwinker: