/**
 *
 * Query metadata
 *
 */

import /* ... CodeQL libraries or modules ... */

/* ... Optional, define CodeQL classes and predicates ... */

from /* ... variable declarations ... */
where /* ... logical formula ... */
select /* ... expressions ... */

from int x, int y, int z
where x in [1..10] and y in [1..10] and z in [1..10] and
      x*x + y*y = z*z
select x, y, z

/**
 * ...
 * @kind path-problem
 * ...
 */

import <language>
// For some languages (Java/C++/Python) you need to explicitly import the data flow library, such as
// import semmle.code.java.dataflow.DataFlow
import DataFlow::PathGraph
...

from MyConfiguration config, DataFlow::PathNode source, DataFlow::PathNode sink
where config.hasFlowPath(source, sink)
select sink.getNode(), source, sink, "<message>"

where config.hasFlowPath(source, sink)

class MyConfig extends TaintTracking::Configuration {
  MyConfig() { this = "MyConfig" }

  override predicate isSource(DataFlow::Node node) { node instanceof MySource }

  override predicate isSink(DataFlow::Node node) { node instanceof MySink }
}

from MyConfig config, DataFlow::PathNode source, DataFlow::PathNode sink
where config.hasFlowPath(source, sink)
select sink.getNode(), source, sink, "Sink is reached from $@.", source.getNode(), "here"

from Person t
where exists(string c | t.getHairColor() = c)
select t

import tutorial

from Person t
where
 /* 1 */ t.getHeight() > 150 and
 /* 2 */ not t.getHairColor() = "blond" and
 /* 3 */ exists (string c | t.getHairColor() = c) and
 /* 4 */ not t.getAge() < 30 and
 /* 5 */ t.getLocation() = "east" and
 /* 6 */ (t.getHairColor() = "black" or t.getHairColor() = "brown") and
 /* 7 */ not (t.getHeight() > 180 and t.getHeight() < 190) and
 /* 8 */ exists(Person p | p.getAge() > t.getAge()) and
 /* 9 */ not t = max(Person p | | p order by p.getHeight()) and
 /* 10 */ t.getHeight() < avg(float i | exists(Person p | p.getHeight() = i) | i) and
 /* 11 */ t = max(Person p | p.getLocation() = "east" | p order by p.getAge())
select "The thief is " + t + " !"

predicate isSouthern(Person p) {
  p.getLocation() =	 "south"
}
...
from Person p
where isSouthern(p)
select p

class Child extends Person{
    Child(){
        this.getAge()<10
    }
    
    override predicate  isAllowedIn(string region) {
        region=this.getLocation()
    }
}

import tutorial

predicate isSouthern (Person p) {
    p.getLocation()="south"
}

class Southerner extends Person{
    Southerner(){
        isSouthern(this)
    }
}

class Child extends Person{
    Child(){
        this.getAge()<10
    }
    
    override predicate  isAllowedIn(string region) {
        region=this.getLocation()
    }
}

predicate isBald(Person p) {
    not exists (string c | p.getHairColor() = c)
  }

from Southerner s 
where s.isAllowedIn("north") and isBald(s)
select s

Person relativeOf(Person p) {
  parentOf*(result) = parentOf*(p)
}

import tutorial

Person relativeOf(Person p) { parentOf*(result) = parentOf*(p) }

predicate hasCriminalRecord(Person p) {
  p = "Hester" or
  p = "Hugh" or
  p = "Charlie"
}

from Person p
where
  not p.isDeceased() and
  p = relativeOf("King Basil") and
  not hasCriminalRecord(p)
select p

/**
 * A solution to the river crossing puzzle.
 */

/** A possible cargo item. */
class Cargo extends string {
  Cargo() {
    this = "Nothing" or
    this = "Goat" or
    this = "Cabbage" or
    this = "Wolf"
  }
}

/** One of two shores. */
class Shore extends string {
  Shore() {
    this = "Left" or
    this = "Right"
  }

  /** Returns the other shore. */
  Shore other() {
    this = "Left" and result = "Right"
    or
    this = "Right" and result = "Left"
  }
}

/** Renders the state as a string. */
string renderState(Shore manShore, Shore goatShore, Shore cabbageShore, Shore wolfShore) {
  result = manShore + "," + goatShore + "," + cabbageShore + "," + wolfShore
}

/** A record of where everything is. */
class State extends string {
  Shore manShore;
  Shore goatShore;
  Shore cabbageShore;
  Shore wolfShore;

  State() { this = renderState(manShore, goatShore, cabbageShore, wolfShore) }

  /** Returns the state that is reached after ferrying a particular cargo item. */
  State ferry(Cargo cargo) {
    cargo = "Nothing" and
    result = renderState(manShore.other(), goatShore, cabbageShore, wolfShore)
    or
    cargo = "Goat" and
    result = renderState(manShore.other(), goatShore.other(), cabbageShore, wolfShore)
    or
    cargo = "Cabbage" and
    result = renderState(manShore.other(), goatShore, cabbageShore.other(), wolfShore)
    or
    cargo = "Wolf" and
    result = renderState(manShore.other(), goatShore, cabbageShore, wolfShore.other())
  }

  /**
   * Holds if the state is safe. This occurs when neither the goat nor the cabbage
   * can get eaten.
   */
  predicate isSafe() {
    // The goat can't eat the cabbage.
    (goatShore != cabbageShore or goatShore = manShore) and
    // The wolf can't eat the goat.
    (wolfShore != goatShore or wolfShore = manShore)
  }

  /** Returns the state that is reached after safely ferrying a cargo item. */
  State safeFerry(Cargo cargo) { result = this.ferry(cargo) and result.isSafe() }

  string towards() {
    manShore = "Left" and result = "to the left"
    or
    manShore = "Right" and result = "to the right"
  }

  /**
   * Returns all states that are reachable via safe ferrying.
   * `path` keeps track of how it is achieved.
   * `visitedStates` keeps track of previously visited states and is used to avoid loops.
   */
  State reachesVia(string path, string visitedStates) {
    // Reachable in 1 step by ferrying a specific cargo
    exists(Cargo cargo |
      result = this.safeFerry(cargo) and
      visitedStates = result and
      path = "First " + cargo + " is ferried " + result.towards()
    )
    or
    // Reachable by first following pathSoFar and then ferrying cargo
    exists(string pathSoFar, string visitedStatesSoFar, Cargo cargo |
      result = this.reachesVia(pathSoFar, visitedStatesSoFar).safeFerry(cargo) and
      not exists(int i | i = visitedStatesSoFar.indexOf(result)) and // resulting state is not visited yet
      visitedStates = visitedStatesSoFar + "_" + result and
      path = pathSoFar + ",\nthen " + cargo + " is ferried " + result.towards()
    )
  }
}

/** The initial state, where everything is on the left shore. */
class InitialState extends State {
  InitialState() { this = renderState("Left", "Left", "Left", "Left") }
}

/** The goal state, where everything is on the right shore. */
class GoalState extends State {
  GoalState() { this = renderState("Right", "Right", "Right", "Right") }
}

from string path
where any(InitialState i).reachesVia(path, _) = any(GoalState g)
select path + "."

import java
  from Variable v, PrimitiveType pt
where pt=v.getType() and
	pt.hasName("boolean")
select v