ViewVC Help

View File | Revision Log | View Changeset | Root Listing

root/Oni2/oup/current/DataAccess/Access_OUP_ADB.pas

Comparing oup/rewrite/DataAccess/Access_OUP_ADB.pas (file contents):
Revision 93 by alloc, Thu Jan 18 17:15:59 2007 UTC vs.
Revision 101 by alloc, Tue Feb 20 20:43:29 2007 UTC

#	Line 1 | Line 1
1		unit Access_OUP_ADB;
2		interface
3
4	<	uses DataAccess;
4	>	uses DataAccess, ABSMain, TypeDefs, Classes;
5
6		type
7		TAccess_OUP_ADB = class(TDataAccess)
8		private
9	<	{    FDatabase: TABSDatabase;
10	<	FQuery:    TABSQuery;
11	<	Fdat_files:    TFiles;
9	>	FDatabase:          TABSDatabase;
10	>	FQuery:             TABSQuery;
11	>	Fdat_files:         TFiles;
12		Fdat_extensionsmap: TExtensionsMap;
13		protected
14		public
15	<	constructor Create(OLDBFilename: String; var Result: Boolean); override;
15	>	constructor Create(DBFilename: String; ConnectionID: Integer; var Msg: TStatusMessages); override;
16		procedure Close; override;
17
18		procedure UpdateListCache;
19	<	//      function GetDatLinks(srcid:LongWord):TDatLinks;
20	<	function GetFileInfo(fileid: Integer): TFileInfo; override;
21	<	function GetFilesList(ext: String; pattern: String;
22	<	NoEmptyFiles: Boolean; sort: TSortType): TStringArray; override;
23	<	function GetFilesCount: LongWord; override;
24	<	function GetExtensionsList: TStringArray; override;
25	<	function GetExtendedExtensionsList: TExtensionsMap; override;
26	<	function GetNamedFilesMap: TNamedFilesMap;
27	<
28	<	function LoadDatFile(fileid: LongWord): Tdata; override;
29	<	procedure UpdateDatFile(fileid: LongWord; Data: Tdata); override;
30	<	procedure LoadDatFilePart(fileid, offset, size: LongWord; target: Pointer); override;
31	<	procedure UpdateDatFilePart(fileid, offset, size: LongWord; target: Pointer); override;
32	<
33	<	function GetRawList(fileid: LongWord): TRawList; override;
34	<	procedure LoadRawFile(fileid, dat_offset: LongWord; target: Pointer); override;
35	<	procedure UpdateRawFile(fileid, dat_offset: LongWord; size: LongWord;
36	<	target: Pointer); override;
37	<	procedure LoadRawFilePart(fileid, dat_offset: LongWord;
38	<	offset, size: LongWord; target: Pointer); override;
39	<	procedure UpdateRawFilePart(fileid, dat_offset: LongWord;
40	<	offset, size: LongWord; target: Pointer); override;
19	>
20	>	function GetFileInfo(FileID: Integer): TFileInfo; override;
21	>	function GetFilesList(Ext: String; Pattern: String;
22	>	NoEmptyFiles: Boolean; SortType: TSortType): TStrings; override;
23	>	function GetFileCount: Integer; override;
24	>	function GetExtensionsList(ExtListFormat: TExtensionFormat): TStrings; override;
25	>
26	>	procedure LoadDatFile(FileID: Integer; var Target: TStream); overload; override;
27	>	procedure UpdateDatFile(FileID: Integer; Src: TStream); overload; override;
28	>	procedure LoadDatFilePart(FileID, Offset, Size: Integer; var Target: TStream); overload; override;
29	>	procedure UpdateDatFilePart(FileID, Offset, Size: Integer; Src: TStream); overload; override;
30	>
31	>	function GetRawList(FileID: Integer): TRawDataList; override;
32	>	function GetRawInfo(FileID, DatOffset: Integer): TRawDataInfo; override;
33	>
34	>	procedure LoadRawFile(FileID, DatOffset: Integer; var Target: TStream); overload; override;
35	>	procedure UpdateRawFile(FileID, DatOffset: Integer; Src: TStream); overload; override;
36	>	procedure LoadRawFilePart(FileID, DatOffset, Offset, Size: Integer; var Target: TStream); overload; override;
37	>	procedure UpdateRawFilePart(FileID, DatOffset, Offset, Size: Integer; Src: TStream); overload; override;
38		published
39	<	}  end;
39	>	end;
40
41
42		implementation
43
44	+	uses
45	+	SysUtils, Data, Functions, ABSDecUtil, DB;
46	+
47
48		(*
49		================================================================================
50		Implementation of  TOniDataADB
51		*)
52
53	<	{
54	<	constructor TOniDataADB.Create(OLDBFilename: String; var Result: Boolean);
53	>
54	>	constructor TAccess_OUP_ADB.Create(DBFilename: String; ConnectionID: Integer; var Msg: TStatusMessages);
55		var
56	<	i, j:  Byte;
57	<	temps: String;
56	>	i: Integer;
57		begin
58	<	if not FileExists(OLDBFilename) then
58	>	Msg := SM_UnknownError;
59	>	if not FileExists(DBFilename) then
60		begin
61	<	ShowMessage('File doesn''t exist!!!');
62	<	Result := False;
61	>	Msg := SM_FileNotFound;
62		Exit;
63		end;
64	<	FFileName := OLDBFilename;
64	>	FFileName := DBFilename;
65	>
66		FDatabase := TABSDatabase.Create(nil);
67	<	FDatabase.DatabaseName := 'OLDBcon';
68	<	FDatabase.DatabaseFileName := OLDBFilename;
67	>	FDatabase.DatabaseName := 'OLDBcon' + IntToStr(ConnectionID);
68	>	FDatabase.DatabaseFileName := DBFilename;
69		FDatabase.Open;
70		FQuery := TABSQuery.Create(FDatabase);
71	<	FQuery.DatabaseName := 'OLDBcon';
71	>	FQuery.DatabaseName := 'OLDBcon' + IntToStr(ConnectionID);
72		FQuery.SQL.Text := 'SELECT [name],[value] FROM globals ORDER BY [name] ASC';
73		FQuery.Open;
74		FQuery.First;
#	Line 77 | Line 77 | begin
77		begin
78		if FQuery.FieldByName('value').AsString <> DBversion then
79		begin
80	<	ShowMessage('Database-file ' + #13 + #10 +
81	<	'"' + OLDBFilename + '"' + #13 + #10 +
82	<	'has wrong version. (Required: ' + DBversion + '; found: ' +
83	<	FQuery.FieldByName('value').AsString + ')');
80	>	Msg := SM_IncompatibleDBVersion;
81		FQuery.Close;
85	–	Result := False;
82		Exit;
83		end;
84		end;
85		if FQuery.FieldByName('name').AsString = 'lvl' then
86	+	FLevelNumber := StrToInt(FQuery.FieldByName('value').AsString);
87	+	if FQuery.FieldByName('name').AsString = 'DataOS' then
88		begin
89	<	FLevelInfo.LevelNumber := StrToInt(FQuery.FieldByName('value').AsString);
90	<	end;
91	<	if FQuery.FieldByName('name').AsString = 'ident' then
92	<	begin
93	<	temps := FQuery.FieldByName('value').AsString;
94	<	for i := 0 to High(FLevelInfo.Ident) do
95	<	begin
96	<	j := i * 2 + 1;
99	<	case temps[j] of
100	<	'0'..'9':
101	<	FLevelInfo.Ident[i] := Ord(temps[j]) - 48;
102	<	'A'..'F':
103	<	FLevelInfo.Ident[i] := Ord(temps[j]) - 55;
104	<	end;
105	<	FLevelInfo.Ident[i] := FLevelInfo.Ident[i] * 16;
106	<	case temps[j + 1] of
107	<	'0'..'9':
108	<	FLevelInfo.Ident[i] := FLevelInfo.Ident[i] + Ord(temps[j + 1]) - 48;
109	<	'A'..'F':
110	<	FLevelInfo.Ident[i] := FLevelInfo.Ident[i] + Ord(temps[j + 1]) - 55;
111	<	end;
112	<	end;
113	<	end;
114	<	if FQuery.FieldByName('name').AsString = 'ident' then
115	<	begin
116	<	temps   := FQuery.FieldByName('value').AsString;
117	<	Fos_mac := temps = 'MAC';
89	>	if FQuery.FieldByName('value').AsString = 'WIN' then
90	>	FDataOS := DOS_WIN
91	>	else if FQuery.FieldByName('value').AsString = 'WINDEMO' then
92	>	FDataOS := DOS_WINDEMO
93	>	else if FQuery.FieldByName('value').AsString = 'MAC' then
94	>	FDataOS := DOS_MAC
95	>	else if FQuery.FieldByName('value').AsString = 'MACBETA' then
96	>	FDataOS := DOS_MACBETA;
97		end;
98		FQuery.Next;
99		until FQuery.EOF;
100		FQuery.Close;
101
102	<	UpdateListCache;
102	>	Msg := SM_OK;
103	>	FBackend := DB_ADB;
104
105	<	Result   := True;
106	<	FBackend := ODB_ADB;
105	>	FChangeRights := [CR_EditDat, CR_EditRaw, CR_ResizeDat, CR_ResizeRaw];
106	>
107	>	UpdateListCache;
108		end;
109
110
111
112
113	<	procedure TOniDataADB.Close;
113	>	procedure TAccess_OUP_ADB.Close;
114		begin
115	+	FQuery.Free;
116		FDatabase.Close;
117		FDatabase.Free;
118		Self.Free;
#	Line 138 | Line 120 | end;
120
121
122
123	<	procedure TOniDataADB.UpdateListCache;
123	>	procedure TAccess_OUP_ADB.UpdateListCache;
124		var
125	<	i:     LongWord;
125	>	i:     Integer;
126		temps: String;
127		begin
128		FQuery.SQL.Text := 'SELECT id,name,extension,[size],contenttype FROM datfiles ORDER BY id ASC;';
129		FQuery.Open;
130	+	SetLength(Fdat_files, FQuery.RecordCount);
131		if FQuery.RecordCount > 0 then
132		begin
133		FQuery.First;
151	–	SetLength(Fdat_files, FQuery.RecordCount);
134		i := 0;
135		repeat
136		Fdat_files[i].ID := FQuery.FieldByName('id').AsInteger;
137		Fdat_files[i].Name := FQuery.FieldByName('name').AsString;
138		Fdat_files[i].Extension := FQuery.FieldByName('extension').AsString;
157	–	Fdat_files[i].FileName := FormatNumber(Fdat_files[i].ID, 5, '0') + '-' +
158	–	Fdat_files[i].Name + '.' + Fdat_files[0].Extension;
159	–	Fdat_files[i].FileNameHex := IntToHex(Fdat_files[i].ID, 4) + '-' +
160	–	Fdat_files[i].Name + '.' + Fdat_files[0].Extension;
139		Fdat_files[i].Size := FQuery.FieldByName('size').AsInteger;
140		Fdat_files[i].FileType := HexToLong(FQuery.FieldByName('contenttype').AsString);
141		Fdat_files[i].DatAddr := 0;
164	–	Fdat_files[i].opened := False;
142		Inc(i);
143		FQuery.Next;
144		until FQuery.EOF;
145		end;
146		FQuery.Close;
147
171	–	SetLength(Fdat_extensionsmap, 0);
148		FQuery.SQL.Text :=
149		'SELECT extension,count(extension) AS x FROM datfiles GROUP BY extension ORDER BY extension ASC;';
150		FQuery.Open;
151	+	SetLength(Fdat_extensionsmap, FQuery.RecordCount);
152		if FQuery.RecordCount > 0 then
153		begin
177	–	SetLength(Fdat_extensionsmap, FQuery.RecordCount);
154		i := 0;
155		repeat
156	<	temps := FQuery.FieldByName('extension').AsString[1];
156	>	temps := FQuery.FieldByName('extension').AsString;
157		Fdat_extensionsmap[i].Extension[3] := temps[1];
158		Fdat_extensionsmap[i].Extension[2] := temps[2];
159		Fdat_extensionsmap[i].Extension[1] := temps[3];
#	Line 191 | Line 167 | begin
167		end;
168
169
170	<	function TOniDataADB.GetFileInfo(fileid: Integer): TFileInfo;
195	<	var
196	<	i: Integer;
170	>	function TAccess_OUP_ADB.GetFileInfo(fileid: Integer): TFileInfo;
171		begin
172		if fileid = -1 then
173		begin
174		Result := inherited GetFileInfo(fileid);
175		Exit;
176		end;
177	<	if fileid < Self.GetFilesCount then
178	<	begin
205	<	for i := 0 to High(Fdat_files) do
206	<	if Fdat_files[i].ID = fileid then
207	<	Break;
208	<	if i < Length(Fdat_files) then
209	<	Result := Fdat_files[i]
210	<	else
211	<	Result.ID := -1;
212	<	end
177	>	if fileid < Self.GetFileCount then
178	>	Result    := Fdat_files[fileid]
179		else
214	–	begin
180		Result.ID := -1;
216	–	end;
181		end;
182
183
184
185
186	<	function TOniDataADB.GetFilesList(ext: String; pattern: String;
187	<	NoEmptyFiles: Boolean; sort: TSortType): TStringArray;
186	>	function TAccess_OUP_ADB.GetFilesList(ext: String; pattern: String;
187	>	NoEmptyFiles: Boolean; SortType: TSortType): TStrings;
188		var
189	<	i: LongWord;
190	<	list: TStringList;
189	>	i:      Integer;
190	>	list:   TStringList;
191		id, name, extension: String;
192		fields: TStrings;
193
194		procedure getfields;
195		begin
196	<	fields.CommaText := StringReplace(AnsiQuotedStr(list.Strings[i], '"'), ';', '","', [rfReplaceAll]);
197	<	if sort in [stIDAsc, stIDDesc] then
196	>	fields.CommaText := StringReplace(AnsiQuotedStr(list.Strings[i], '"'), ';', '","', [rfReplaceAll]);
197	>	if SortType in [ST_IDAsc, ST_IDDesc] then
198		begin
199		id := fields.Strings[0];
200		name := fields.Strings[1];
201		extension := fields.Strings[2];
202		end;
203	<	if sort in [stNameAsc, stNameDesc] then
203	>	if SortType in [ST_NameAsc, ST_NameDesc] then
204		begin
205		id := fields.Strings[1];
206		name := fields.Strings[0];
207		extension := fields.Strings[2];
208		end;
209	<	if sort in [stExtAsc, stExtDesc] then
209	>	if SortType in [ST_ExtAsc, ST_ExtDesc] then
210		begin
211		id := fields.Strings[1];
212		name := fields.Strings[2];
#	Line 253 | Line 217 | var
217		begin
218		list := TStringList.Create;
219		list.Sorted := True;
220	<	for i := 0 to High(Fdat_files) do
220	>	for i := 0 to GetFileCount - 1 do
221		begin
222		if ((Length(ext) = 0) or (Pos(Fdat_files[i].Extension, ext) > 0)) and
223		((Length(pattern) = 0) or
#	Line 268 | Line 232 | begin
232		name := Fdat_files[i].Name;
233		extension := Fdat_files[i].Extension;
234
235	<	case sort of
236	<	stIDAsc, stIDDesc:     list.Add(id + ';' + name + ';' + extension);
237	<	stNameAsc, stNameDesc: list.Add(name + ';' + id + ';' + extension);
238	<	stExtAsc, stExtDesc:   list.Add(extension + ';' + id + ';' + name);
235	>	case SortType of
236	>	ST_IDAsc, ST_IDDesc:     list.Add(id + ';' + name + ';' + extension);
237	>	ST_NameAsc, ST_NameDesc: list.Add(name + ';' + id + ';' + extension);
238	>	ST_ExtAsc, ST_ExtDesc:   list.Add(extension + ';' + id + ';' + name);
239		end;
240		end;
241		end;
242		end;
243	<	SetLength(Result, list.Count);
244	<	fields := TStringList.Create;
245	<	if sort in [stIDAsc, stNameAsc, stExtAsc] then
246	<	for i := 0 to list.Count - 1 do
247	<	begin
248	<	getfields;
249	<	Result[i] := id + '-' + name + '.' + extension;
250	<	end
251	<	else
252	<	for i := list.Count - 1 downto 0 do
253	<	begin
254	<	getfields;
255	<	Result[list.Count - i - 1] := id + '-' + name + '.' + extension;
256	<	end;
243	>	Result := TStringList.Create;
244	>	if list.Count > 0 then
245	>	begin
246	>	fields := TStringList.Create;
247	>	if SortType in [ST_IDAsc, ST_NameAsc, ST_ExtAsc] then
248	>	for i := 0 to list.Count - 1 do
249	>	begin
250	>	getfields;
251	>	Result.Add(id + '-' + name + '.' + extension);
252	>	end
253	>	else
254	>	for i := list.Count - 1 downto 0 do
255	>	begin
256	>	getfields;
257	>	Result.Add(id + '-' + name + '.' + extension);
258	>	end;
259	>	fields.Free;
260	>	end;
261		list.Free;
294	–	fields.Free;
262		end;
263
264
265
266
267	<	function TOniDataADB.GetFilesCount: LongWord;
267	>	function TAccess_OUP_ADB.GetFileCount: Integer;
268		begin
269		Result := Length(Fdat_files);
270		end;
271
272
273	<
307	<
308	<	function TOniDataADB.GetExtensionsList: TStringArray;
273	>	function TAccess_OUP_ADB.GetExtensionsList(ExtListFormat: TExtensionFormat): TStrings;
274		var
275	<	i: LongWord;
275	>	i: Integer;
276		begin
277	<	SetLength(Result, Length(Fdat_extensionsmap));
278	<	for i := 0 to High(Result) do
277	>	Result := TStringList.Create;
278	>	for i := 0 to Length(Fdat_extensionsmap) - 1 do
279		begin
280		with Fdat_extensionsmap[i] do
281		begin
282	<	Result[i] := Extension[3] + Extension[2] + Extension[1] + Extension[0] +
283	<	' (' + IntToStr(ExtCount) + ')';
282	>	case ExtListFormat of
283	>	EF_ExtOnly:
284	>	Result.Add(Extension[3] + Extension[2] + Extension[1] + Extension[0]);
285	>	EF_ExtCount:
286	>	Result.Add(Extension[3] + Extension[2] + Extension[1] + Extension[0] +
287	>	' (' + IntToStr(ExtCount) + ')');
288	>	end;
289		end;
290		end;
291		end;
292
293
294	<
325	<
326	<	function TOniDataADB.GetExtendedExtensionsList: TExtensionsMap;
294	>	procedure TAccess_OUP_ADB.LoadDatFile(FileID: Integer; var Target: TStream);
295		var
296	<	i, j:  LongWord;
297	<	temps: String;
330	<	Data:  Tdata;
331	<	begin
332	<	SetLength(Result, 0);
333	<	FQuery.SQL.Text := 'SELECT ext,ident FROM extlist ORDER BY ext ASC;';
334	<	FQuery.Open;
335	<	if FQuery.RecordCount > 0 then
336	<	begin
337	<	SetLength(Result, FQuery.RecordCount);
338	<	i := 0;
339	<	repeat
340	<	temps := FQuery.FieldByName('ext').AsString;
341	<	for j := 0 to 3 do
342	<	Result[i].Extension[j] := temps[4 - j];
343	<	Data := DecodeHexString(FQuery.FieldByName('ident').AsString);
344	<	for j := 0 to 7 do
345	<	Result[i].Ident[j] := Data[j];
346	<	Inc(i);
347	<	FQuery.Next;
348	<	until FQuery.EOF;
349	<	end;
350	<	FQuery.Close;
351	<	end;
352	<
353	<
354	<
355	<
356	<	function TOniDataADB.GetNamedFilesMap: TNamedFilesMap;
357	<	var
358	<	i:     LongWord;
359	<	temp:  Integer;
360	<	temps: String;
361	<	temparray: array of record
362	<	id: Integer;
363	<	fullname: String[50];
364	<	end;
296	>	mem: TStream;
297	>	streampos: Integer;
298		begin
299	<	SetLength(temparray, 0);
367	<	FQuery.SQL.Text :=
368	<	'SELECT id,(extension+name) AS xname FROM datfiles WHERE Length(name)>0 ORDER BY extension,name ASC;';
369	<	FQuery.Open;
370	<	if FQuery.RecordCount > 0 then
371	<	begin
372	<	repeat
373	<	temp  := FQuery.FieldByName('id').AsInteger;
374	<	temps := FQuery.FieldByName('xname').AsString;
375	<
376	<	SetLength(temparray, Length(temparray) + 1);
377	<	if Length(temparray) > 1 then
378	<	begin
379	<	for i := High(temparray) - 1 downto 0 do
380	<	begin
381	<	if StringSmaller(temps, temparray[i].fullname) then
382	<	begin
383	<	temparray[i + 1] := temparray[i];
384	<	if i = 0 then
385	<	begin
386	<	temparray[i].id := temp;
387	<	temparray[i].fullname := temps;
388	<	end;
389	<	end
390	<	else
391	<	begin
392	<	temparray[i + 1].id := temp;
393	<	temparray[i + 1].fullname := temps;
394	<	Break;
395	<	end;
396	<	end;
397	<	end
398	<	else
399	<	begin
400	<	temparray[0].id := temp;
401	<	temparray[0].fullname := temps;
402	<	end;
403	<	FQuery.Next;
404	<	until FQuery.EOF;
405	<	end;
406	<	FQuery.Close;
407	<	SetLength(Result, Length(temparray));
408	<	for i := 0 to High(temparray) do
299	>	if fileid < GetFileCount then
300		begin
301	<	Result[i].FileNumber := temparray[i].id;
302	<	Result[i].blubb      := 0;
412	<	end;
413	<	end;
414	<
415	<
301	>	if not Assigned(Target) then
302	>	Target := TMemoryStream.Create;
303
304	+	streampos := Target.Position;
305
418	–	function TOniDataADB.LoadDatFile(fileid: LongWord): Tdata;
419	–	var
420	–	mem: TStream;
421	–	begin
422	–	if fileid < Self.GetFilesCount then
423	–	begin
306		FQuery.SQL.Text := 'SELECT data FROM datfiles WHERE id=' + IntToStr(fileid) + ';';
307		FQuery.Open;
308		if FQuery.RecordCount > 0 then
309		begin
310		mem := FQuery.CreateBlobStream(FQuery.FieldByName('data'), bmRead);
429	–	SetLength(Result, mem.Size);
311		mem.Seek(0, soFromBeginning);
312	<	mem.Read(Result[0], mem.Size);
312	>	Target.CopyFrom(mem, mem.Size);
313		mem.Free;
314		end;
315		FQuery.Close;
316	+
317	+	Target.Seek(streampos, soFromBeginning);
318		end;
319		end;
320
321	<
439	<
440	<
441	<	procedure TOniDataADB.UpdateDatFile(fileid: LongWord; Data: Tdata);
321	>	procedure TAccess_OUP_ADB.UpdateDatFile(FileID: Integer; Src: TStream);
322		var
323		MimeCoder: TStringFormat_MIME64;
324		mem: TMemoryStream;
325		begin
326	<	if fileid < Self.GetFilesCount then
326	>	if fileid < GetFileCount then
327		begin
328		mimecoder := TStringFormat_MIME64.Create;
329		mem := TMemoryStream.Create;
330	<	mem.Write(Data[0], Length(Data));
451	<	mem.Seek(0, soFromBeginning);
330	>	mem.CopyFrom(Src, Src.Size);
331		FQuery.SQL.Text := 'UPDATE datfiles SET data=MimeToBin("' +
332		MimeCoder.StrTo(mem.Memory, mem.Size) + '"), size=' + IntToStr(mem.Size) +
333		' WHERE id=' + IntToStr(fileid) + ';';
#	Line 456 | Line 335 | begin
335		mem.Free;
336		mimecoder.Free;
337		end;
459	–	UpdateListCache;
338		end;
339
340
341
342	<
465	<	procedure TOniDataADB.LoadDatFilePart(fileid, offset, size: LongWord; target: Pointer);
342	>	procedure TAccess_OUP_ADB.LoadDatFilePart(FileID, Offset, Size: Integer; var Target: TStream);
343		var
344	+	streampos: Integer;
345		mem: TStream;
346		begin
347	<	if fileid < Self.GetFilesCount then
347	>	if fileid < GetFileCount then
348		begin
349	+	if not Assigned(Target) then
350	+	Target := TMemoryStream.Create;
351	+	streampos := Target.Position;
352	+
353		FQuery.SQL.Text := 'SELECT data FROM datfiles WHERE id=' + IntToStr(fileid) + ';';
354		FQuery.Open;
355		if FQuery.RecordCount > 0 then
356		begin
357		mem := FQuery.CreateBlobStream(FQuery.FieldByName('data'), bmRead);
358		mem.Seek(offset, soFromBeginning);
359	<	mem.Read(target^, size);
359	>	Target.CopyFrom(mem, size);
360		mem.Free;
361		end;
362		FQuery.Close;
363	+	Target.Seek(streampos, soFromBeginning);
364		end;
365		end;
366
367
368
369	<
487	<	procedure TOniDataADB.UpdateDatFilePart(fileid, offset, size: LongWord; target: Pointer);
369	>	procedure TAccess_OUP_ADB.UpdateDatFilePart(FileID, Offset, Size: Integer; Src: TStream);
370		var
371		MimeCoder: TStringFormat_MIME64;
372		mem:  TMemoryStream;
491	–	Data: Tdata;
373		begin
374	<	if fileid < Self.GetFilesCount then
374	>	if fileid < GetFileCount then
375		begin
376	<	Data := Self.LoadDatFile(fileid);
377	<	mimecoder := TStringFormat_MIME64.Create;
378	<	mem := TMemoryStream.Create;
379	<	mem.Write(Data[0], Length(Data));
499	<	mem.Seek(offset, soFromBeginning);
500	<	mem.Write(target^, size);
376	>	mem := nil;
377	>	LoadDatFile(fileid, TStream(mem));
378	>	mem.Seek(Offset, soFromBeginning);
379	>	mem.CopyFrom(Src, Size);
380		mem.Seek(0, soFromBeginning);
381	+	mimecoder := TStringFormat_MIME64.Create;
382		FQuery.SQL.Text := 'UPDATE datfiles SET data=MimeToBin("' +
383		MimeCoder.StrTo(mem.Memory, mem.Size) + '") WHERE id=' + IntToStr(fileid) + ';';
384		FQuery.ExecSQL;
#	Line 508 | Line 388 | begin
388		end;
389
390
391	<
512	<
513	<	function TOniDataADB.GetRawList(fileid: LongWord): TRawList;
391	>	function TAccess_OUP_ADB.GetRawList(FileID: Integer): TRawDataList;
392		var
393	<	i: LongWord;
393	>	i: Integer;
394		begin
395		SetLength(Result, 0);
396		FQuery.SQL.Text := 'SELECT [src_link_offset],[size],[sep] FROM rawmap WHERE [src_id]=' +
#	Line 524 | Line 402 | begin
402		SetLength(Result, FQuery.RecordCount);
403		i := 0;
404		repeat
405	<	Result[i].src_id     := fileid;
406	<	Result[i].src_offset := FQuery.FieldByName('src_link_offset').AsInteger;
407	<	Result[i].raw_addr   := 0;
408	<	Result[i].raw_size   := FQuery.FieldByName('size').AsInteger;
409	<	Result[i].loc_sep    := FQuery.FieldByName('sep').AsBoolean;
405	>	Result[i].SrcID     := fileid;
406	>	Result[i].SrcOffset := FQuery.FieldByName('src_link_offset').AsInteger;
407	>	Result[i].RawAddr   := 0;
408	>	Result[i].RawSize   := FQuery.FieldByName('size').AsInteger;
409	>	Result[i].LocSep    := FQuery.FieldByName('sep').AsBoolean;
410		Inc(i);
411		FQuery.Next;
412		until FQuery.EOF;
#	Line 537 | Line 415 | begin
415		end;
416
417
418	+	function TAccess_OUP_ADB.GetRawInfo(FileID, DatOffset: Integer): TRawDataInfo;
419	+	var
420	+	i: Integer;
421	+	rawlist: TRawDataList;
422	+	begin
423	+	rawlist := GetRawList(FileID);
424	+	if Length(rawlist) > 0 then
425	+	begin
426	+	for i := 0 to High(rawlist) do
427	+	if rawlist[i].SrcOffset = DatOffset then
428	+	Break;
429	+	if i < Length(rawlist) then
430	+	Result := rawlist[i]
431	+	else begin
432	+	Result.SrcID     := -1;
433	+	Result.SrcOffset := -1;
434	+	Result.RawAddr   := -1;
435	+	Result.RawSize   := -1;
436	+	end;
437	+	end;
438	+	end;
439	+
440
441
442	<	procedure TOniDataADB.LoadRawFile(fileid, dat_offset: LongWord; target: Pointer);
442	>	procedure TAccess_OUP_ADB.LoadRawFile(FileID, DatOffset: Integer; var Target: TStream);
443		var
444		mem: TStream;
445	+	streampos: Integer;
446		begin
447	<	if fileid < Self.GetFilesCount then
447	>	if fileid < GetFileCount then
448		begin
449	+	if not Assigned(Target) then
450	+	Target := TMemoryStream.Create;
451	+	streampos := Target.Position;
452		FQuery.SQL.Text := 'SELECT data FROM rawmap WHERE (src_id=' +
453	<	IntToStr(fileid) + ') AND (src_link_offset=' + IntToStr(dat_offset) + ');';
453	>	IntToStr(FileID) + ') AND (src_link_offset=' + IntToStr(DatOffset) + ');';
454		FQuery.Open;
455		if FQuery.RecordCount > 0 then
456		begin
457		mem := FQuery.CreateBlobStream(FQuery.FieldByName('data'), bmRead);
458		mem.Seek(0, soFromBeginning);
459	<	mem.Read(target^, mem.size);
459	>	Target.CopyFrom(mem, mem.Size);
460		mem.Free;
461		end;
462		FQuery.Close;
463	+	Target.Seek(streampos, soFromBeginning);
464		end;
465		end;
466
467
468	<
564	<
565	<	procedure TOniDataADB.UpdateRawFile(fileid, dat_offset: LongWord;
566	<	size: LongWord; target: Pointer);
468	>	procedure TAccess_OUP_ADB.UpdateRawFile(FileID, DatOffset: Integer; Src: TStream);
469		var
470		MimeCoder: TStringFormat_MIME64;
471		mem: TMemoryStream;
472		begin
473	<	if fileid < Self.GetFilesCount then
473	>	if fileid < GetFileCount then
474		begin
475		mimecoder := TStringFormat_MIME64.Create;
476		mem := TMemoryStream.Create;
477	<	mem.Write(target^, size);
477	>	mem.CopyFrom(Src, Src.Size);
478		mem.Seek(0, soFromBeginning);
479		FQuery.SQL.Text := 'UPDATE rawmap SET data=MimeToBin("' + MimeCoder.StrTo(
480	<	mem.Memory, mem.Size) + '") WHERE (src_id=' + IntToStr(fileid) +
481	<	') AND (src_link_offset=' + IntToStr(dat_offset) + ');';
480	>	mem.Memory, mem.Size) + '") WHERE (src_id=' + IntToStr(FileID) +
481	>	') AND (src_link_offset=' + IntToStr(DatOffset) + ');';
482		FQuery.ExecSQL;
483		mem.Free;
484		mimecoder.Free;
#	Line 586 | Line 488 | end;
488
489
490
491	<	procedure TOniDataADB.LoadRawFilePart(fileid, dat_offset: LongWord;
590	<	offset, size: LongWord; target: Pointer);
491	>	procedure TAccess_OUP_ADB.LoadRawFilePart(FileID, DatOffset, Offset, Size: Integer; var Target: TStream);
492		var
592	–	Data: Tdata;
493		mem:  TMemoryStream;
494	+	streampos: Integer;
495		begin
496	<	if fileid < Self.GetFilesCount then
496	>	if fileid < GetFileCount then
497		begin
498	<	SetLength(Data, Self.GetRawInfo(fileid, dat_offset).raw_size);
499	<	Self.LoadRawFile(fileid, dat_offset, @Data[0]);
500	<	mem := TMemoryStream.Create;
501	<	mem.Write(Data[offset], size);
502	<	mem.Read(target^, size);
498	>	if not Assigned(Target) then
499	>	Target := TMemoryStream.Create;
500	>	streampos := Target.Position;
501	>	mem := nil;
502	>	LoadRawFile(FileID, DatOffset, TStream(mem));
503	>	mem.Seek(Offset, soFromBeginning);
504	>	Target.CopyFrom(mem, Size);
505		mem.Free;
506	+	Target.Seek(streampos, soFromBeginning);
507		end;
508		end;
509
510
511
512
513	<	procedure TOniDataADB.UpdateRawFilePart(fileid, dat_offset: LongWord;
610	<	offset, size: LongWord; target: Pointer);
513	>	procedure TAccess_OUP_ADB.UpdateRawFilePart(FileID, DatOffset, Offset, Size: Integer; Src: TStream);
514		var
515		MimeCoder: TStringFormat_MIME64;
516		mem:  TMemoryStream;
614	–	Data: Tdata;
517		begin
518	<	if fileid < Self.GetFilesCount then
518	>	if fileid < GetFileCount then
519		begin
520	<	SetLength(Data, Self.GetRawInfo(fileid, offset).raw_size);
521	<	Self.LoadRawFile(fileid, offset, @Data[0]);
620	<	mimecoder := TStringFormat_MIME64.Create;
621	<	mem := TMemoryStream.Create;
622	<	mem.Write(Data[0], Length(Data));
520	>	mem := nil;
521	>	LoadRawFile(fileid, offset, TStream(mem));
522		mem.Seek(offset, soFromBeginning);
523	<	mem.Write(target^, size);
523	>	mem.CopyFrom(Src, Size);
524		mem.Seek(0, soFromBeginning);
525	+	mimecoder := TStringFormat_MIME64.Create;
526		FQuery.SQL.Text := 'UPDATE rawmap SET data=MimeToBin("' + MimeCoder.StrTo(
527		mem.Memory, mem.Size) + '") WHERE (src_id=' + IntToStr(fileid) +
528	<	') AND (src_link_offset=' + IntToStr(dat_offset) + ');';
528	>	') AND (src_link_offset=' + IntToStr(DatOffset) + ');';
529		FQuery.ExecSQL;
530		mem.Free;
531		mimecoder.Free;
532		end;
533		end;
534
535	<	}
535	>
536
537
538		end.

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)