-       A connection from an application program to the PostgreSQL
      server has to be established. The application program transmits a
      query to the server and receives the results sent back by the server.
      
-       The parser stage checks the query
      transmitted by the application
      program (client) for correct syntax and creates
      a query tree.
      
-       The rewrite system takes
      the query tree created by the parser stage and looks for
      any rules (stored in the
      system catalogs) to apply to 
      the querytree and performs the
      transformations given in the rule bodies.
      One application of the rewrite system is given in the realization of
      views.
      -       Whenever a query against a view
      (i.e. a virtual table) is made,
      the rewrite system rewrites the user's query to
      a query that accesses the base tables given in
      the view definition instead.
      
-       The planner/optimizer takes
      the (rewritten) querytree and creates a 
      queryplan that will be the input to the
      executor.
      -       It does so by first creating all possible paths
      leading to the same result. For example if there is an index on a
      relation to be scanned, there are two paths for the
      scan. One possibility is a simple sequential scan and the other
      possibility is to use the index. Next the cost for the execution of
      each plan is estimated and the
      cheapest plan is chosen and handed back.
      
-       The executor recursively steps through
      the plan tree and
      retrieves tuples in the way represented by the plan.
      The executor makes use of the
      storage system while scanning
      relations, performs sorts and joins,
      evaluates qualifications and finally hands back the tuples derived.