<%
1. Response.Cookies("siteName")= "DevTutorials"
2. siteName = Response.Cookies("siteName")
3. response.write ("Site Name is :" & siteName & vbnewline)
%>

<%
0. Response.Cookies(("siteName").Expires= Now()+15
1. Response.Cookies("siteName")= "DevTutorials"
2. siteName = Response.Cookies("siteName")
3. response.write ("Site Name is :" & siteName & vbnewline)
%>

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add('CREATE TABLE "'+tbl+'"');
SQL.Add('('+fld1+' '+tp1+', '+'fld2'+' '+tp2+')');
SQL;
end;

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add(' INTO "'+Tbl+'"');
SQL.Add('VALUES ('+val1+', '+val2+', "'+val3+'")');
SQL;
end;

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add('SELECT *');
SQL.Add('FROM "'+Tbl+'"');
Active:=True;
end;

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add('SELECT *');
SQL.Add('FROM "'+Tbl+'"');
SQL.Add('WHERE '+Fld+' = "'+Val+'"');
Active:=True;
end;

SQL.Add('WHERE '+Fld+' LIKE "%'+Val+'%"');

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add('SELECT Max('+Fld+') as M');
SQL.Add('FROM "'+Tbl+'"');
Active:=True;
end;

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add('');
SQL.Add('FROM "'+Tbl+'"');
SQL.Add('WHERE '+Fld+' = "'+Val+'"');
SQL;
end;

with MyQuery do
begin
Active:=False;
SQL.Clear;
SQL.Add('UPDATE "'+Tbl+'"');
SQL.Add('SET '+UpdFld+' = "'+UpdVal+'"');
SQL.Add('WHERE '+Fld+' = "'+Val+'"');
SQL;
end;

Session1.SessionName:='init';
Session1.AddStandardAlias('GamesAlias', 'c:new_bd', 'PARADOX');
Table1.DatabaseName:='GamesAlias';
Table1.TableName:='games.db';
Table1.Active:=True;

2. Регистация базы данных (алиаса)

var List: TStringList;
...
Session1.SessionName:='init';
List := TStringList.Create;
List.Add('PATH=c:new_bd');
List.Add('DEFAULT DRIVER=paradox');
Session1.AddAlias('GamesAlias', 'STANDARD', List);
List.Free;
...
Table1.DatabaseName:='GamesAlias';
Table1.TableName:='games.db';
Table1.Active:=True;

Session1.Alias('GamesAlias');

Session1.IsAlias('games1');

Table1.;
TBlobField(Table1.FieldByName('my_pic1')).LoadFile(OpenDialog1.FileName);
TBlobField(Table1.FieldByName('my_pic2')).Assign(Image1.Picture);
Table1.Post;

Image2.Picture.Assign(TBlobField(Table1.FieldByName('my_pic1')));

FSession := TSession.Create(nil);

FDatabase := TDatabase.Create(nil);
FSession.SessionName := 'DBSession'
FDatabase.Connected := False;
FDatabase.AliasName := Database;
FDatabase.DatabaseName := USER_DATABASE;
FDatabase.SessionName := FSession.SessionName;

FUserTBL := TTable.Create(nil);
FUserTBL.DatabaseName := FDatabase.DatabaseName;
FUserTBL.SessionName := FSession.SessionName;
FUserTBL.TableName := USERTBL;
FUserTBL.IndexName := USERSpIndex;

FUserSource := TDataSource.Create(nil);
FUserSource.DataSet := FUserTBL;

unit Unit2;

interface
uses db, DBTables, dialogs;

type fake = class(Ttable)

procedure fakeFilterRecord(DataSet: TDataSet; var Accept: Boolean);
end;

var

MyTable : fake;

implementation

procedure fake.fakeFilterRecord(DataSet: TDataSet; var Accept: Boolean);
begin

showmessage('Здравствуй, Вася');
end;

Initialization

MyTable := fake.create(nil);
With Mytable do begin
DataBaseName := 'dbdemos';
TableName := 'biolife';
OnFilterRecord := MyTable.fakeFilterRecord;
Filtered := true;
active := true;
end;


{проверка получением неких данных...}
showmessage(MyTable.fields[1].asstring);

Finalization
{Важно! MyTable не имеет родителя, - уничтожаем объект сами, иначе память не высвобождается...}
MyTable.free;

end.

Procedure SaveGrid;
var f:textfile;
x,y:integer;
begin
assignfile (f,'Filename');
rewrite (f);
writeln (f,stringgrid.colcount);
writeln (f,stringgrid.rowcount);
For X:=0 to stringgrid.colcount-1 do

For y:=0 to stringgrid.rowcount-1 do
writeln (F, stringgrid.cells[x,y]);
closefile (f);
end;

Procedure LoadGrid;
var f:textfile;
temp,x,y:integer;
tempstr:string;
begin
assignfile (f,'Filename');
reset (f);
readln (f,temp);
stringgrid.colcount:=temp;
readln (f,temp);
stringgrid.rowcount:=temp;
For X:=0 to stringgrid.colcount-1 do

For y:=0 to stringgrid.rowcount-1 do begin
readln (F, tempstr);
stringgrid.cells[x,y]:=tempstr;
end;
closefile (f);
end;

implementation

{$R *.DFM}

var n: integer; // При инициализации программы данное значение будет равным нулю

procedure TForm1.Button1Click(Sender: TObject);
var Image: TBitmap;
begin // Изменение иконки в BitBtn1

Image:= TBitmap.Create;
if n < ImageList1.Count then
ImageList1.GetBitmap(n, Image);
{end if}


BitBtn1.Glyph.Assign(Image) // Примечание: Для изменения свойств объекта используется метод Assign


inc(n,2); // В данный момент кнопка содержит две иконки!
if n > ImageList1.Count then
n:= 0;
{end if}
Image.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin // добавляем новую иконку кнопки в список ImageList1
if OpenDialog1.ute then
ImageList1.FileLoad(rtBitMap,OpenDialog1.FileName,clBtnFace);
label1.Caption:= 'Количество иконок = ' + IntToStr(ImageList1.Count);
end;

const

MCI_INFO_PRODUCT = $00000100;
MCI_INFO_FILE = $00000200;
MCI_INFO_MEDIA_UPC = $00000400;
MCI_INFO_MEDIA_IDENTITY = $00000800;
MCI_INFO_NAME = $00001000;
MCI_INFO_COPYRIGHT = $00002000;

{ блок параметров для командного сообщения MCI_INFO }
type

PMCI_Info_ParmsA = ^TMCI_Info_ParmsA;
PMCI_Info_ParmsW = ^TMCI_Info_ParmsW;
PMCI_Info_Parms = PMCI_Info_ParmsA;
TMCI_Info_ParmsA = record
dwCallback: DWORD;
lpstrReturn: PAnsiChar;
dwRetSize: DWORD;
end;
TMCI_Info_ParmsW = record
dwCallback: DWORD;
lpstrReturn: PWideChar;
dwRetSize: DWORD;
end;
TMCI_Info_Parms = TMCI_Info_ParmsA;

uses DbiProcs, DBiTypes;

function GetDataBaseDir(const Alias : string): String;
(* Возвращает каталог расположения базы данных по заданному псевдониму

(без обратного слеша) *)
var

sp : PChar;
Res : pDBDesc;
begin

try
New(Res);
sp := StrAlloc(length(Alias)+1);
StrPCopy(sp,Alias);
if DbiGetDatabaseDesc(sp,Res) = 0
then Result := StrPas(Res^.szPhyName)
else Result := '';
finally
StrDispose(sp);
Dispose(Res);
end;
end;

uses

SysUtils, Windows, Messages, Classes, Graphics, Controls,
Forms, Dialogs, ExtCtrls, StdCtrls, IniFiles, TypInfo, Debug;

type

TUniqueReader = Class(TReader)
LastRead: TComponent;
procedure ComponentRead(Component: TComponent);
procedure SetNameUnique(
Reader: TReader;
Component: TComponent;
var Name: string
);
end;

implementation

procedure TUniqueReader.ComponentRead(

Component: TComponent
);
begin

LastRead := Component;
end;

procedure TUniqueReader.SetNameUnique( // Задаем уникальное имя считываемому компоненту

Reader: TReader;
Component: TComponent; // Считываемый компонент
var Name: string // Имя компонента для дальнейшей модификации
);
var

i: Integer;
tempname: string;
begin

i := 0;
tempname := Name;
while Component.Owner.FindComponent(Name) <> nil do begin
Inc(i);
Name := Format('%s%d', [tempname, i]);
end;
end;


function DuplicateComponents(

AComponent: TComponent // исходный компонент
): TComponent; // возвращаемся к созданию нового компонента

procedure RegisterComponentClasses(
AComponent: TComponent
);
var
i : integer;
begin
RegisterClass(TPersistentClass(AComponent.ClassType));
if AComponent is TWinControl then
if TWinControl(AComponent).ControlCount > 0 then
for i := 0 to
(TWinControl(AComponent).ControlCount-1) do

RegisterComponentClasses(TWinControl(AComponent).Controls[i]);

end;

var

Stream: TMemoryStream;
UniqueReader: TUniqueReader;
Writer: TWriter;
begin

result := nil;
UniqueReader := nil;
Writer := nil;


try
Stream := TMemoryStream.Create;
RegisterComponentClasses(AComponent);


try
Writer := TWriter.Create(Stream, 4096);
Writer.Root := AComponent.Owner;
Writer.WriteSignature;
Writer.WriteComponent(AComponent);
Writer.WriteListEnd;
finally
Writer.Free;
end;


Stream.Position := 0;
try
UniqueReader := TUniqueReader.Create(Stream, 4096); // создаем поток, перемещающий данные о компоненте в конструктор
UniqueReader.OnSetName := UniqueReader.SetNameUnique;
UniqueReader.LastRead := nil;


if AComponent is TWinControl then

UniqueReader.ReadComponents(
// считываем компоненты и суб-компоненты

TWinControl(AComponent).Owner,
TWinControl(AComponent).Parent,
UniqueReader.ComponentRead
)
else

UniqueReader.ReadComponents(
// читаем компоненты

AComponent.Owner,
nil,
UniqueReader.ComponentRead
);
result := UniqueReader.LastRead;
finally
UniqueReader.Free;
end;
finally
Stream.Free;
end;
end;

procedure TConvertForm.CopyTable(FromDir, SrcTblName, ToDir, DestTblName: String);
var

DBHandle: HDBIDB;
ResultCode: DBIResult;
Src, Dest, Err: Array[0..255] of Char;
SrcTbl, DestTbl: TTable;
begin

SrcTbl := TTable.Create(Application);
DestTbl := TTable.Create(Application);
try
SrcTbl.DatabaseName := FromDir;
SrcTbl.TableName := SrcTblName;
SrcTbl.Open;
DBHandle := SrcTbl.DBHandle;
SrcTbl.Close;
ResultCode := DbiCopyTable(DBHandle,false,
StrPCopy(Src,FromDir + '' + SrcTblName),nil,
StrPCopy(Dest,ToDir + '' + DestTblName));
if (ResultCode <> DBIERR_NONE) then
begin
DbiGetErrorString(ResultCode,Err);
raise EDatabaseError.Create('При копировании ' +
FromDir + '' + SrcTblName + ' в ' +
ToDir + '' + DestTblName + ' ,'
+ 'BDE сгенерировал ошибку '''
+ StrPas(Err) + '''');
end;
finally
SrcTbl.Free;
DestTbl.Free;
end;
end;

procedure TConvertForm.Table(Dir, TblName: String);
var

DBHandle: HDBIDB;
ResultCode: DBIResult;
tbl, Err: Array[0..255] of Char;
SrcTbl, DestTbl: TTable;
SrcTbl := TTable.Create(Application);
try
SrcTbl.DatabaseName := Dir;
SrcTbl.TableName := TblName;
SrcTbl.Open;
DBHandle := SrcTbl.DBHandle;
SrcTbl.Close;
ResultCode := DbiTable(DBHandle,
StrPCopy(Tbl,Dir + '' + TblName),nil);
if (ResultCode <> DBIERR_NONE) then
begin
DbiGetErrorString(ResultCode,Err);
raise EDatabaseError.Create('Удаляя ' +
Dir + '' + TblName + ', BDE ' +
'сгенерировал ошибку '''
+ StrPas(Err) + '''');
end;
finally
SrcTbl.Free;
end;
end;

(*****************************************************************************
* DbUtils.pas
*
* Утилита для работы с базами данных
*****************************************************************************)
unit Dbutils;

(****************************************************************************)
(****************************************************************************)

interface
(****************************************************************************)
(****************************************************************************)

uses

DbTables;

function DbGetVersion(table: TTable): LongInt;


(****************************************************************************)
(****************************************************************************)

implementation
(****************************************************************************)
(****************************************************************************)

uses

Db, DbiProcs, DbiTypes, {DbiErrs,}
SysUtils;


{-}
(*

* Цель: определение номера версии структуры таблицы
* Параметры: table (I) - интересующая нас таблица
* Возвращаемая величина: номер версии
* Исключительная ситуация: EDatabaseError
*)
function DbGetVersion(table: TTable): LongInt;
var

hCursor : hDBICur;
tableDesc: TBLFullDesc;
cName : array[0..255] of Char;
begin

{ копируем имя таблицы в строку 'с' }
StrPCopy(cName, table.TableName);


{ просим BDE создать запись, содержащую информацию об определенной таблице }
Check(DbiOpenTableList(table.DBHandle, True, False, cName, hCursor));


{ получаем запись, содержащую информацию о структуре }
Check(DbiGetNextRecord(hCursor, dbiNOLOCK, @tableDesc, nil));


{ возвращаем поле записи, содержащее номер версии структуры нашей таблицы }
Result := tableDesc.tblExt.iRestrVersion;


Check(DbiCloseCursor(hCursor));
end;

end.

unit Finder;

interface

uses DB, DBTables, SysUtils;

function GrabMemoFieldAsPChar(TheField : TMemoField): PChar;
function DoFindIn(TheField : TField; SFor : String): Boolean;
function FindIt(TheTable : TDataSet; TheFields : array of integer;

SearchBackward : Boolean; Beginning : Boolean; SFor : String): Boolean;
{применение функции FindIt -

if FindIt(NotesSearchT,
[NotesSearchT.FieldByName('Leadman').Index],
False, True, SearchText.Text) then DoSomething; }

implementation

function GrabMemoFieldAsPChar(TheField : TMemoField): PChar;
begin
with TBlobStream.Create(TheField, bmRead) do

begin
GetMem(Result, Size + 1);
FillChar(Result^, Size + 1, #0);
Read(Result^, Size);
Free;
end;
end;

function DoFindIn(TheField : TField; SFor : String): Boolean;
var

PChForMemo : PChar;
begin
Result := False;
case TheField.DataType of

ftString :
begin
if (Pos(SFor, UpperCase(TheField.AsString)) > 0) then
Result := True;
end;
ftInteger :
begin
if (Pos(SFor, TheField.AsString) > 0) then Result := True;
end;
ftBoolean :
begin
if SFor = UpperCase(TheField.AsString) then
Result := True;
end;
ftFloat :
begin
if (Pos(SFor, TheField.AsString) > 0) then Result := True;
end;
ftCurrency :
begin
if (Pos(SFor, TheField.AsString) > 0) then Result := True;
end;
ftDate .. ftDateTime :
begin
if (Pos(SFor, TheField.AsString) > 0) then Result := True;
end;
ftMemo :
begin
SFor[Ord(SFor[0]) + 1] := #0;
PChForMemo := GrabMemoFieldAsPChar(TMemoField(TheField));
StrUpper(PChForMemo);
if not (StrPos( PChForMemo, @SFor[1] ) = nil) then Result :=
True; FreeMem(PChForMemo, StrLen(PChForMemo + 1));
end;
end;
end;

function FindIt(TheTable : TDataSet; TheFields : array of integer;

SearchBackward : Boolean; Beginning : Boolean; SFor : String): Boolean;
var

i, HighTheFields, LowTheFields : integer;
BM : TBookmark;
begin
TheTable.DisableControls;
BM := TheTable.GetBookmark;
try
LowTheFields := Low(TheFields);
HighTheFields := High(TheFields);
SFor := UpperCase(SFor);
Result := False;
if Beginning then TheTable.First;
if SearchBackward then

begin
TheTable.Prior;
while not TheTable.BOF do
begin
for i := LowTheFields to HighTheFields do
begin
if DoFindIn(TheTable.Fields[TheFields[i]], SFor) then
begin
Result := True;
Break;
end;
end;
if Result then Break else TheTable.Prior;
end;
end else
begin
TheTable.Next;
while not TheTable.EOF do
begin
for i := LowTheFields to HighTheFields do
begin
if DoFindIn(TheTable.Fields[TheFields[i]], SFor) then
begin
Result := True;
Break;
end;
end;
if Result then Break else TheTable.Next;
end;
end;
finally
TheTable.EnableControls;
if not Result then

TheTable.GotoBookmark(BM);
TheTable.FreeBookmark(BM);
end;

end;

end.

uses DB, DBTables, StdCtrls;

procedure TForm1.Button1Click(Sender: TObject);
var

tSource, TDest: TTable;
begin
TSource := TTable.create(self);
with TSource do begin
DatabaseName := 'dbdemos';
TableName := 'customer.db';
open;
end;
TDest := TTable.create(self);
with TDest do begin
DatabaseName := 'dbdemos';
TableName := 'MyNewTbl.db';
FieldDefs.Assign(TSource.FieldDefs);
IndexDefs.Assign(TSource.IndexDefs);
CreateTable;
end;
TSource.close;
end;