xqbase.pas

TxQuery is an SQL engine implemented in a TDataSet descendant component, that can parse SQL syntax,

{-------------------------------------------------------------------------------}
{                  Implement TTableItem                                         }
{-------------------------------------------------------------------------------}

Constructor TTableItem.Create( TableList: TTableList );
Begin
  Inherited Create;
  fTableList := TableList;
  fNumSubquery:= -1;  // means no subquery defined for this
End;

{-------------------------------------------------------------------------------}
{                  Implement TTableList                                         }
{-------------------------------------------------------------------------------}

Constructor TTableList.Create;
Begin
  Inherited Create;
  fItems := TList.Create;
End;

Destructor TTableList.Destroy;
Begin
  Clear;
  fItems.Free;
  Inherited Destroy;
End;

Function TTableList.GetCount;
Begin
  Result := fItems.Count;
End;

Function TTableList.GetItem( Index: Integer ): TTableItem;
Begin
  Result := fItems[Index];
End;

Function TTableList.Add: TTableItem;
Begin
  Result := TTableItem.Create( Self );
  fItems.Add( Result );
End;

Procedure TTableList.Clear;
Var
  I: Integer;
Begin
  For I := 0 To fItems.Count - 1 Do
    TTableItem( fItems[I] ).Free;
  fItems.Clear;
End;

Procedure TTableList.Delete( Index: Integer );
Begin
  TTableItem( fItems[Index] ).Free;
  fItems.Delete( Index );
End;

Function TTableList.IndexOfDataSet( DataSet: TDataSet ): Integer;
Var
  Idx: Integer;
Begin
  Result := -1;
  For Idx := 0 To fItems.Count - 1 Do
    If TTableItem( fItems[Idx] ).DataSet = DataSet Then
    Begin
      Result := Idx;
      Exit;
    End;
End;

Function TTableList.IndexOfTableName( Const tableName: String ): Integer; // 1.56 fix
Var
  Idx: Integer;
Begin
  Result := -1;
  For Idx := 0 To fItems.Count - 1 Do
    If AnsiCompareText( TTableItem( fItems[Idx] ).TableName, TableName ) = 0 Then
    Begin
      Result := Idx;
      Exit;
    End;
End;

Function TTableList.IndexOfAlias( Const Alias: String ): Integer; // 1.56 fix
Var
  Idx: Integer;
Begin
  Result := -1;
  For Idx := 0 To fItems.Count - 1 Do
    If AnsiCompareText( TTableItem( fItems[Idx] ).Alias, Alias ) = 0 Then
    Begin
      Result := Idx;
      Exit;
    End;
End;

{-------------------------------------------------------------------------------}
{                  Implement TOrderByItem                                       }
{-------------------------------------------------------------------------------}

Constructor TOrderByItem.Create( OrderByList: TOrderByList );
Begin
  Inherited Create;
  fOrderByList := OrderByList;
End;

{-------------------------------------------------------------------------------}
{                  Implement TOrderByList                                       }
{-------------------------------------------------------------------------------}

Constructor TOrderByList.Create;
Begin
  Inherited Create;
  fItems := TList.Create;
End;

Destructor TOrderByList.Destroy;
Begin
  Clear;
  fItems.Free;
  Inherited Destroy;
End;

Function TOrderByList.GetCount;
Begin
  Result := fItems.Count;
End;

Function TOrderByList.GetItem( Index: Integer ): TOrderByItem;
Begin
  Result := fItems[Index];
End;

Function TOrderByList.Add: TOrderByItem;
Begin
  Result := TOrderByItem.Create( Self );
  fItems.Add( Result );
End;

Procedure TOrderByList.Clear;
Var
  I: Integer;
Begin
  For I := 0 To fItems.Count - 1 Do
    TOrderByItem( fItems[I] ).Free;
  fItems.Clear;
End;

Procedure TOrderByList.Delete( Index: Integer );
Begin
  TOrderByItem( fItems[Index] ).Free;
  fItems.Delete( Index );
End;

{-------------------------------------------------------------------------------}
{                  Implement TUpdateItem                                        }
{-------------------------------------------------------------------------------}

Constructor TUpdateItem.Create( UpdateList: TUpdateList );
Begin
  Inherited Create;
  fUpdateList := UpdateList;
End;

Destructor TUpdateItem.Destroy;
Begin
  If Assigned( fResolver ) Then
    fResolver.Free;
  Inherited Destroy;
End;

{-------------------------------------------------------------------------------}
{                  Implement TUpdateList                                        }
{-------------------------------------------------------------------------------}

Function TUpdateList.GetCount;
Begin
  Result := fItems.Count;
End;

Function TUpdateList.GetItem( Index: Integer ): TUpdateItem;
Begin
  Result := fItems[Index];
End;

Constructor TUpdateList.Create;
Begin
  Inherited Create;
  fItems := TList.Create;
End;

Destructor TUpdateList.Destroy;
Begin
  Clear;
  fItems.Free;
  Inherited Destroy;
End;

Function TUpdateList.Add: TUpdateItem;
Begin
  Result := TUpdateItem.Create( Self );
  fItems.Add( Result );
End;

Procedure TUpdateList.Clear;
Var
  I: Integer;
Begin
  For I := 0 To fItems.Count - 1 Do
    TUpdateItem( fItems[I] ).Free;
  fItems.Clear;
End;

Procedure TUpdateList.Delete( Index: Integer );
Begin
  TUpdateItem( fItems[Index] ).Free;
  fItems.Delete( Index );
End;

{-------------------------------------------------------------------------------}
{                  Implement TWhereOptimizeItem                                 }
{-------------------------------------------------------------------------------}

Constructor TWhereOptimizeItem.Create( WhereOptimizeList: TWhereOptimizeList );
Begin
  Inherited Create;
  fWhereOptimizeList := WhereOptimizeList;
End;

{-------------------------------------------------------------------------------}
{                  Implement TWhereOptimizeList                                 }
{-------------------------------------------------------------------------------}

Function TWhereOptimizeList.GetCount;
Begin
  Result := fItems.Count;
End;

Function TWhereOptimizeList.GetItem( Index: Integer ): TWhereOptimizeItem;
Begin
  Result := fItems[Index];
End;

Constructor TWhereOptimizeList.Create;
Begin
  Inherited Create;
  fItems := TList.Create;
End;

Destructor TWhereOptimizeList.Destroy;
Begin
  Clear;
  fItems.Free;
  Inherited Destroy;
End;

Procedure TWhereOptimizeList.Assign( OptimizeList: TWhereOptimizeList );
Var
  Item: TWhereOptimizeItem;
  I: Integer;
Begin
  Clear;
  For I := 0 To OptimizeList.Count - 1 Do
  Begin
    Item := Self.Add;
    With OptimizeList[I] Do
    Begin
      Item.DataSet := Dataset;
      Item.FieldNames := Fieldnames;
      Item.RangeStart := Rangestart;
      Item.Rangeend := Rangeend;
      Item.RelOperator := Reloperator;
      Item.CanOptimize := Canoptimize;
    End;
  End;
End;

Function TWhereOptimizeList.Add: TWhereOptimizeItem;
Begin
  Result := TWhereOptimizeItem.Create( Self );
  fItems.Add( Result );
End;

Procedure TWhereOptimizeList.Clear;
Var
  I: Integer;
Begin
  For I := 0 To fItems.Count - 1 Do
    TWhereOptimizeItem( fItems[I] ).Free;
  fItems.Clear;
End;

Procedure TWhereOptimizeList.Delete( Index: Integer );
Begin
  TWhereOptimizeItem( fItems[Index] ).Free;
  fItems.Delete( Index );
End;

{-------------------------------------------------------------------------------}
{                  Implement TCreateField                                       }
{-------------------------------------------------------------------------------}

Constructor TCreateField.Create( CreateFields: TCreateFields );
Begin
  Inherited Create;
  fCreateFields := CreateFields;
End;

{-------------------------------------------------------------------------------}
{                  Implement TCreateFields                                      }
{-------------------------------------------------------------------------------}

Constructor TCreateFields.Create;
Begin
  Inherited Create;
  fList := TList.Create;
End;

Destructor TCreateFields.Destroy;
Begin
  Clear;
  fList.Free;
  Inherited;
End;

Procedure TCreateFields.AddField( Const AName: String;
  AFieldType,
  AScale,
  APrecision,
  ASize,
  ABlobType: Integer;
  AMustDrop: Boolean );
Var
  NewField: TCreateField;
Begin
  NewField := TCreateField.Create( Self );
  With NewField Do
  Begin
    FieldName := AName;
    FieldType := AFieldType;
    Scale := AScale;
    Precision := APrecision;
    Size := ASize;
    BlobType := ABlobType;
    MustDrop := AMustDrop;
  End;
  fList.Add( NewField );
End;

Procedure TCreateFields.Clear;
Var
  I: Integer;
Begin
  For I := 0 To fList.Count - 1 Do
    TCreateField( fList[I] ).Free;
  fList.Clear;
End;

Function TCreateFields.Get( Index: Integer ): TCreateField;
Begin
  Result := Nil;
  If ( Index < 0 ) Or ( Index > fList.Count - 1 ) Then
    exit;
  Result := TCreateField( fList[Index] );
End;

Function TCreateFields.Count: Integer;
Begin
  Result := fList.Count;
End;

{-------------------------------------------------------------------------------}
{                  Implement TCreateTableItem                                   }
{-------------------------------------------------------------------------------}

Constructor TCreateTableItem.Create( CreateTableList: TCreateTableList );
Begin
  Inherited Create;
  fCreateTableList := CreateTableList;
  fFields := TCreateFields.Create;
  fPrimaryKey := TStringList.Create;
End;

Destructor TCreateTableItem.Destroy;
Begin
  fFields.Free;
  fPrimaryKey.Free;
  Inherited Destroy;
End;

Function TCreateTableItem.FieldCount: Integer;
Begin
  Result := fFields.Count;
End;

{-------------------------------------------------------------------------------}
{                  Implement TCreateTableList                                   }
{-------------------------------------------------------------------------------}

Constructor TCreateTableList.Create;
Begin
  Inherited Create;
  fItems := TList.Create;
End;

Destructor TCreateTableList.Destroy;
Begin
  Clear;
  fItems.Free;
  Inherited Destroy;
End;

Function TCreateTableList.GetCount;
Begin
  Result := fItems.Count;
End;

Function TCreateTableList.GetItem( Index: Integer ): TCreateTableItem;
Begin
  Result := fItems[Index];
End;

Function TCreateTableList.Add: TCreateTableItem;
Begin
  Result := TCreateTableItem.Create( Self );
  fItems.Add( Result );
End;

Procedure TCreateTableList.Clear;
Var
  I: Integer;
Begin
  For I := 0 To fItems.Count - 1 Do
    TCreateTableItem( fItems[I] ).Free;
  fItems.Clear;
End;

Procedure TCreateTableList.Delete( Index: Integer );
Begin
  TCreateTableItem( fItems[Index] ).Free;
  fItems.Delete( Index );
End;

{-------------------------------------------------------------------------------}
{                  Implement TInsertItem                                        }