Added logo
Modified unit test to include alias/table name reference for column, and fix related bug
Merge branch 'master' of github.com:forcedotcom/phoenix
Project only what's necessary into scan, better encapsulate index maintenance
Fix compiler errors (based on eclipse settings in phoenix/dev)
Fix caching of index maintainers on codec
Fix broken unit test
Update README.md
Update README.md
Lazy-load selected columns for current row state

Before, we were loading all the columns of the row into memory.
This could be wildly inefficient as we just care about a small
subset of the columns (usually) for indexing. Now, we just load the
columns the user requests per-index, on demand.

This lead to an issue (esp when combined with the local HRegion reads)
where two KVs with the same row-key (r,f,q,ts) would sort in the wrong
order based on memstore timestamp. Resolved this with a custom KV
comparator that always sorts the pending updates (as PendingKeyValue)
before regular keyvalues, in the case that everything is the same.

Really, we should probably also rip out the ExposedMemStore and go
with a cleaner, simpler implementation. That's a V2 thing, but adding
comments to this effect.
Add closing to scanners.

Scanners were not being closed, causing a resource leak on the
underlying MemStore. While this was fine for short operations
(the ExposedMemStore was the only reference and it was let go after
building the index updates for each mutation), it could be an issue
for longer operations or operations that need to create a lot of
scanners (e.g. lots of indexes).

Now the scanners are allowed to be GC'ed.
Add unit tests for setting covered column to new value and null, workaround the inability to pass through both a Put and Delete for a row, project only what's necessary in skip scan
Moved ImmutableBytesPtr into index.util package and use in place of ImmutableBytesWritable for Map keys
Change PERCENTILE_RANK to correct name of PERCENT_RANK
Adding custom memstore impl.

We basically wrap a KeyValueSkipListSet, just
like a regular MemStore, except we are (1) not
dealing with (a) space considerations or (b) a snapshot
set, and (2) ignoring memstore timestamps in favor of
deciding when we want to overwrite keys based on how we
obtain them.

We can ignore the memstore timestamps because we know that
anything we get from the local region is going to be MVCC
visible - so it should just go in. However, we also want
overwrite any existing state with our pending write that
we are indexing, so that needs to clobber the KVs we get
from the HRegion. This got really messy with a regular
memstore as each KV from the MemStore frequently has a
higher MemStoreTS, but we can't just up the pending KVs'
MemStoreTs b/c a memstore relies on the MVCC readpoint,
which generally is < Long.MAX_VALUE.

By realizing that we don't need the snapshot or space
requirements, we can go much faster than the previous
implementation. Further, by being smart about how we
manage the KVs, we can drop the extra object creation
we were doing to wrap the pending KVs (which we did
previously to ensure they sorted before the ones we got
from the HRegion).
Merge pull request #438 from jyates/replace-memstore-with-custom-impl

Adding custom memstore implemenation for indexing
Fix select * and select cf.* ordering when index table used
More comments
Tweak test
Replacing Strings w/ bytes in Indexer.

Saves us the serialization/deserialization to Strings we did previously.