SparkSQL

Create a Blaze backend for SparkSQL.  This uses the SQLAlchemy backend to generate SQL and then pass that in to a `SchemaRDD`.  Execution example below.

### Example

```Python
In [1]: from blaze import *

In [2]: csv = CSV('examples/data/iris.csv')

In [3]: df = into(DataFrame, csv)

In [4]: df[:5]
Out[4]: 
   sepal_length  sepal_width  petal_length  petal_width      species
0           5.1          3.5           1.4          0.2  Iris-setosa
1           4.9          3.0           1.4          0.2  Iris-setosa
2           4.7          3.2           1.3          0.2  Iris-setosa
3           4.6          3.1           1.5          0.2  Iris-setosa
4           5.0          3.6           1.4          0.2  Iris-setosa

In [5]: import pyspark

In [6]: sc = pyspark.SparkContext('local', 'simple-app')

In [7]: sqlContext = pyspark.SQLContext(sc)

In [8]: srdd = into(sqlContext, df)

In [9]: srdd
Out[9]: MapPartitionsRDD[5] at mapPartitions at SchemaRDD.scala:413

In [10]: srdd.schema()
Out[10]: StructType(List(StructField(sepal_length,DoubleType,false),StructField(sepal_width,DoubleType,false),StructField(petal_length,DoubleType,false),StructField(petal_width,DoubleType,false),StructField(species,StringType,false)))

In [11]: t = Table(srdd)

In [12]: t
Out[12]: 
    sepal_length  sepal_width  petal_length  petal_width      species
0            5.1          3.5           1.4          0.2  Iris-setosa
1            4.9          3.0           1.4          0.2  Iris-setosa
2            4.7          3.2           1.3          0.2  Iris-setosa
3            4.6          3.1           1.5          0.2  Iris-setosa
4            5.0          3.6           1.4          0.2  Iris-setosa
5            5.4          3.9           1.7          0.4  Iris-setosa
6            4.6          3.4           1.4          0.3  Iris-setosa
7            5.0          3.4           1.5          0.2  Iris-setosa
8            4.4          2.9           1.4          0.2  Iris-setosa
9            4.9          3.1           1.5          0.1  Iris-setosa
...

In [13]: by(t.species, petal_max=t.petal_length.max(), petal_min=t.petal_length.min())
Out[13]: 
           species  petal_max  petal_min
0      Iris-setosa        1.9        1.0
1  Iris-versicolor        5.1        3.0
2   Iris-virginica        6.9        4.5
```

### Thoughts

This is not as robust as other backends for a combination of two reasons

1.  Our SQLAlchemy backend often produces less-than-amazing SQL
2.  The SparkSQL parser is somewhat finicky

The PySpark backend is already supported and likely significantly more robust.  We should do some performance testing to see if this is worth it.

### TODO 

- [ ] Hook in UDFs
- [x] Hook this up to the comprehensive test suite
- [ ] Investigate if postgres is the best dialect to send to SparkSQL