C>Schools schools=getAllSchools();
C>for(int x=0;x<coll.size();x++)
C>{
C>    Human h=coll.get(x);
C>    if (h.getAge()>27)
C>    {
C>       for (int y=0;y<schools.size();y++)
C>          if (schools.get(x).getStudents().hasObject(h))
C>           resultColl.add(h);
C>    }
C>}
C>

public static bool Predicate(Human h)
{
    if (h.Age<=27)
        return false;
        
  foreach(School school in Schools)
    {
        if school.Students.Contains(h)
            return true;
    }
    return false;
}

public static bool Predicate(Human h)
{
    return (h.Age>27) && (AllStudents.Contains(h));
}

public static bool Predicate(StudentRecord studentRecord)
{
    return (student.Person.Age>27);
}
...

foreach(IStudent student in GlobalExtent.Select(Predicate))
{
    System.Console.Writeln(student);
}

public static bool Predicate(Human h)

{
    return (sin(h.Age)>0.2763) && (AllStudents.Contains(h));
}

select * from IPerson p where p.Age>27;

create view IPerson as
select ID, Age from Person1
union 
select ID, DateDiff(Year, GetDate(), Birthdate) from Person2

select * from Events e where e.Accepts(@me) and e.Begins between GetDate() and Tomorrow();

create procedure GetAcceptableEvents (@me Person)
as
  select ID from MovieSessions ms 
    inner join Movie m on ms.Movie = m.ID
      inner join MovieCategory с on m.Category = c.ID
      where c.MinAge<=@me.Age
            and ms.StartTime between GetDate() and Tomorrow()
union 
  select ID from PeepShow ps where @me.Gender = MALE and @me.Age>=21
            aand ps.StartTime between GetDate() and Tomorrow()
union
  ...

Schools
   collect: [:school | school students surname]
   where: [:school | school students age <= 27]

glorpSession
   readManyOf: Human
   where: [:each | each school notNIL and: [each age <= 27]]
   orderBy: #surname

glorpSession returningManyOf: Human where: [:each |
   each exists: (Query readManyOf: Schools where: [:eachSchool |
       (eachSchool students
         anySatisfy: [:eachHuman | eachHuman = each)])].

[key<number>]
[persist]
struct MyDocRow : DbRow {
    int number;

    [index(SortAsc)]
    date docDate;

    int state;
};

[persist]
struct MyDocDetail : DbRow {
    refRow<MyDocRow> doc;
    
    money rowSum;
};


bool filter1(MyDocRow& docRow) { return state==5; };

struct filter2 {
   money threshold;
   filter2(money threshold) {this.threshold = threshold; }
   bool operator()(MyDocDetail& docDetail) { return rowSum>=threshold; }
}

[...]

struct DocSums : TmpRow {
    int docNumber;
    money docSum;    

    static Calculate(MyDocRow& docRow, Enumerator<MyDocDetail> detail) {
        docNumber = row.number;
        docSum = agregate_sum<MyDocDetail::rowSum>(detail);
    }
}

// целевой алгоритм
Enumerator<DocSums> GetDocSums(money threshold, date date1, date date2) {
    Enumerator<MyDocRow> docEnumerator = sort<MyDocRow::number, SortAsc>(seek(ByIndex<MyDocRow::docDate>(date1, date2)), filter1);
    NestedEnumerator<MyDocRow, MyDocDetail> docWithDetailEnumerator = join<MyDocDetail::doc>(docEnumerator, filter2(threshold));

    return transform<DocSums>(docWithDetailEnumerator, DocSums::Calculate);
}