people_db.roga

module People { @People, Person, Location, oldestPeopleNear }

type @People :: [Person]

type Person :: {
  name :: String
  age :: Uint
  location :: Location
}

type Location :: {
  lat :: Lattitude
  long :: Longitude
}

type @Locations :: [Location]

type City :: {
  name :: String
  Country :: Country
  location :: Location
}

type @Cities :: [City]

// query from graph db
let oldestPeopleNear loc =
  ? p <- Person
  ! (Location.isNear p.location loc)
  !> (orderBy (ascending .age))
  // same as:
  // !> (orderBy (.age |> ascending))
  // // .age is syntax sugar for: let .age p = p.age
  // // same as:
  // !> (orderBy ((p -> p.age) |> ascending))
  // // same as:
  // !> (orderBy ((p1 p2 -> p1.age <=> p2.age) |> ascending))

let oldestPeopleNear loc personLimit =
  ? p <- (oldestPeopleNear loc)
  ! (limit personLimit)
  !> p

// add some locations
let Germany = Country{name: "Germany"}
let Osnabrueck = City{
  name: "Osnabrück",
  country: Germany,
  location: Location{lat: 150, long: 150}
}
let Bremen = City{
  name: "Bremen",
  country: Germany,
  location: Location{lat: 150, long: 250}
}

let addLocations =
  [
    @Cities
    |> new [Bremen, Osnabrueck],

    // alternative:
    @Locations
    |> new [
      Bremen.location#{city: Bremen},
      Osnabrueck.location#{city: Osnabrueck}
    ]
  ]

let locationsNearOsna =
  locationsWithin Osnabrueck.location (10 |> km)

let locationsWithin loc maxDistance =
  ? l <- @Locations
  ! ((Location.distance l loc) <= maxDistance)
  !> l

// same as:
let locationsWithin loc maxDistance =
  (from @Locations)
  |> where (l -> (Location.distance l loc) <= maxDistance)

let locationsInGermany =
  ? l <- @Locations
  ! l#{country: Germany}
  !> l

let hasPlaceForUpTo maxNum query =
  ? l <- query
  ! l.maxCapacity >= maxNum
  !> l

let funPlaces city =
  ? l <- @Locations
  ! l#{isFun | relaxing | (hasPlaceForUpTo 20)}
  !> l

let funLocationsInBerlinOrHamburg =
  ? l <- @Locations
  ! l#{city: (Berlin | Hamburg)}
  ! l <- funPlaces (Berlin | Hamburg)
  !> l


// MAIN variations

let main ({ db }) =
  db.exec addLocations

let main ({ db }) =
  addLocations
  |> List.map db.exec

let main ({ db }) =
  db.exec <- addLocations