anchor.diff:  Maybe postgres know where the problem lies. Let's use the http://www.postgresql.org/docs/current/static/sql-explain.html[explain] statement to request the execution plan:
   
   ```
  -Sort  (cost=47685.86..47705.35 rows=7796 width=4480)
  -  Sort Key: A.order
  -  Sort Method: external sort  Disk: 4568kB
  -  ->  Nested Loop Left Join  (cost=0.42..17172.90 rows=7796 width=4480)
  -        ->  Nested Loop  (cost=0.14..14475.63 rows=7796 width=3299)
  -              ->  Index Scan using B_pkey on B B  (cost=0.14..8.16 rows=1 width=1590)
  -                    Index Cond: ((id)::text = 'my_cool_id'::text)
  -              ->  Seq Scan on A A  (cost=0.00..14389.51 rows=7796 width=1709)
  -                    Filter: ((B_id)::text = 'my_cool_id'::text)
  -                    Rows Removed by Filter: 399589
  -        ->  Index Scan using C_pkey on C C  (cost=0.28..0.34 rows=1 width=1181)
  -              Index Cond: ((A.C_id)::text = (id)::text)
  -
  -```
  -
  -Remember when I said C also "know" B?
  -That is where I started.  I also included the B filter on all joins.
  +Limit  (cost=20499.31..20499.56 rows=100 width=4505) (actual time=121.947..121.956 rows=100 loops=1)
  +  Buffers: shared hit=23034 read=10916
  +  ->  Sort  (cost=20499.31..20519.32 rows=8003 width=4505) (actual time=121.946..121.947 rows=100 loops=1)
  +        Sort Key: A.order
  +        Sort Method: top-N heapsort  Memory: 126kB
  +        Buffers: shared hit=23034 read=10916
  +        ->  Nested Loop Left Join  (cost=0.28..20193.44 rows=8003 width=4505) (actual time=58.003..117.868 rows=7590 loops=1)
  +              Buffers: shared hit=23034 read=10916
  +              ->  Nested Loop  (cost=0.00..17364.52 rows=8003 width=3323) (actual time=57.960..89.738 rows=7590 loops=1)
  +                    Buffers: shared hit=264 read=10916
  +                    ->  Seq Scan on B B  (cost=0.00..40.58 rows=1 width=1614) (actual time=0.013..0.061 rows=1 loops=1)
  +                          Filter: ((id)::text = 'my_cool_id'::text)
  +                          Rows Removed by Filter: 325
  +                          Buffers: shared hit=36
  +                    ->  Seq Scan on A A  (cost=0.00..17243.91 rows=8003 width=1709) (actual time=57.942..88.880 rows=7590 loops=1)
  +                          Filter: ((B_id)::text = 'my_cool_id'::text)
  +                          Rows Removed by Filter: 480403
  +                          Buffers: shared hit=228 read=10916
  +              ->  Index Scan using C_pkey on C C  (cost=0.28..0.34 rows=1 width=1182) (actual time=0.003..0.003 rows=1 loops=7590)
  +                    Index Cond: ((A.C_id)::text = (id)::text)
  +                    Buffers: shared hit=22770
  +Total runtime: 122.064 ms
  +
  +```
  +
  +Before I start optimizing based on what I can see on explain, remember when I said C also "knows" B?
  +That is where I start.  I also included the B filter on all joins.
   ```
        select A.*, B.*, C.*
        from A A 
  
positive.code: 
  Resulting in:
  ```
  Sort  (cost=40802.22..40821.87 rows=7858 width=4498)
    Sort Key: A.order
    Sort Method: external sort  Disk: 4568kB
    ->  Hash Left Join  (cost=285.02..9885.81 rows=7858 width=4498)
          Hash Cond: ((A.C_id)::text = (C.id)::text)
          ->  Nested Loop  (cost=221.47..9792.31 rows=7858 width=3317)
                ->  Index Scan using B_pkey on B B  (cost=0.14..8.16 rows=1 width=1608)
                      Index Cond: ((id)::text = 'my_cool_id'::text)
                ->  Bitmap Heap Scan on A A  (cost=221.32..9705.57 rows=7858 width=1709)
                      Recheck Cond: ((B_id)::text = 'my_cool_id'::text)
                      ->  Bitmap Index Scan on A_B_id_idx  (cost=0.00..219.36 rows=7858 width=0)
                            Index Cond: ((B_id)::text = 'my_cool_id'::text)
          ->  Hash  (cost=62.63..62.63 rows=74 width=1181)
                Buckets: 1024  Batches: 1  Memory Usage: 13kB
                ->  Bitmap Heap Scan on C C  (cost=4.85..62.63 rows=74 width=1181)
                      Recheck Cond: ((B_id)::text = 'my_cool_id'::text)
                      ->  Bitmap Index Scan on C_B_id_idx  (cost=0.00..4.84 rows=74 width=0)
                            Index Cond: ((B_id)::text = 'my_cool_id'::text)
  ```
  
  This resulted in a more significant cost reduction and a huge time reduction.  From 147ms to 40ms.
  
  While I was doing this, I realized that A.order + A.B_id needed an unique index.
  So I needed a new index to handle that:
  ```
  
negative.code: 
  This simple action reduces the cost of the query a little bit:
  ```
  Limit  (cost=17803.87..17804.12 rows=100 width=4505) (actual time=101.080..101.090 rows=100 loops=1)
    Buffers: shared hit=297 read=10948
    ->  Sort  (cost=17803.87..17823.88 rows=8003 width=4505) (actual time=101.079..101.082 rows=100 loops=1)
          Sort Key: A.order
          Sort Method: top-N heapsort  Memory: 126kB
          Buffers: shared hit=297 read=10948
          ->  Hash Left Join  (cost=103.10..17498.00 rows=8003 width=4505) (actual time=62.598..97.085 rows=7590 loops=1)
                Hash Cond: ((A.C_id)::text = (C.id)::text)
                Buffers: shared hit=297 read=10948
                ->  Nested Loop  (cost=0.00..17364.52 rows=8003 width=3323) (actual time=62.185..94.505 rows=7590 loops=1)
                      Buffers: shared hit=232 read=10948
                      ->  Seq Scan on B B  (cost=0.00..40.58 rows=1 width=1614) (actual time=0.015..0.065 rows=1 loops=1)
                            Filter: ((id)::text = 'my_cool_id'::text)
                            Rows Removed by Filter: 325
                            Buffers: shared hit=36
                      ->  Seq Scan on A A  (cost=0.00..17243.91 rows=8003 width=1709) (actual time=62.165..93.658 rows=7590 loops=1)
                            Filter: ((B_id)::text = 'my_cool_id'::text)
                            Rows Removed by Filter: 480403
                            Buffers: shared hit=196 read=10948
                ->  Hash  (cost=102.22..102.22 rows=70 width=1182) (actual time=0.395..0.395 rows=66 loops=1)
                      Buckets: 1024  Batches: 1  Memory Usage: 13kB
                      Buffers: shared hit=65
                      ->  Seq Scan on C C  (cost=0.00..102.22 rows=70 width=1182) (actual time=0.028..0.385 rows=66 loops=1)
                            Filter: ((B_id)::text = 'my_cool_id'::text)
                            Rows Removed by Filter: 2883
                            Buffers: shared hit=65
  Total runtime: 101.213 ms
  ```
  
  That alone shaves 20 ms, nothing special, but it's a start.  The query still take 101 ms to go, it's better, but ain't THAT better.
  
  
  ##### 1st problem: `Seq Scan`
  