diff --git a/superset/assets/branding/Full Lockup With Text.svg b/superset/assets/branding/FullLockupWithText.svg
similarity index 100%
rename from superset/assets/branding/Full Lockup With Text.svg
rename to superset/assets/branding/FullLockupWithText.svg
diff --git a/superset/assets/branding/Full Lockup With Text@2x.png b/superset/assets/branding/FullLockupWithText@2x.png
similarity index 100%
rename from superset/assets/branding/Full Lockup With Text@2x.png
rename to superset/assets/branding/FullLockupWithText@2x.png
diff --git a/superset/assets/branding/Full Lockup Without Text@1x.svg b/superset/assets/branding/FullLockupWithoutText@1x.svg
similarity index 100%
rename from superset/assets/branding/Full Lockup Without Text@1x.svg
rename to superset/assets/branding/FullLockupWithoutText@1x.svg
diff --git a/superset/assets/branding/Full Lockup Without Text@2x.png b/superset/assets/branding/FullLockupWithoutText@2x.png
similarity index 100%
rename from superset/assets/branding/Full Lockup Without Text@2x.png
rename to superset/assets/branding/FullLockupWithoutText@2x.png
diff --git a/superset/assets/branding/Solo Mark.png b/superset/assets/branding/SoloMark.png
similarity index 100%
rename from superset/assets/branding/Solo Mark.png
rename to superset/assets/branding/SoloMark.png
diff --git a/superset/assets/branding/Solo Mark@1x.svg b/superset/assets/branding/SoloMark@1x.svg
similarity index 100%
rename from superset/assets/branding/Solo Mark@1x.svg
rename to superset/assets/branding/SoloMark@1x.svg
diff --git a/superset/assets/javascripts/components/OnPasteSelect.jsx b/superset/assets/javascripts/components/OnPasteSelect.jsx
new file mode 100644
index 0000000000000..b043bf317d175
--- /dev/null
+++ b/superset/assets/javascripts/components/OnPasteSelect.jsx
@@ -0,0 +1,87 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import Select from 'react-select';
+
+export default class OnPasteSelect extends React.Component {
+  onPaste(evt) {
+    if (!this.props.multi) {
+      return;
+    }
+    evt.preventDefault();
+    const clipboard = evt.clipboardData.getData('Text');
+    if (!clipboard) {
+      return;
+    }
+    const regex = `[${this.props.separator}]+`;
+    const values = clipboard.split(new RegExp(regex)).map(v => v.trim());
+    const validator = this.props.isValidNewOption;
+    const selected = this.props.value || [];
+    const existingOptions = {};
+    const existing = {};
+    this.props.options.forEach((v) => {
+      existingOptions[v[this.props.valueKey]] = 1;
+    });
+    let options = [];
+    selected.forEach((v) => {
+      options.push({ [this.props.labelKey]: v, [this.props.valueKey]: v });
+      existing[v] = 1;
+    });
+    options = options.concat(values
+      .filter((v) => {
+        const notExists = !existing[v];
+        existing[v] = 1;
+        return notExists && (validator ? validator({ [this.props.labelKey]: v }) : !!v);
+      })
+      .map((v) => {
+        const opt = { [this.props.labelKey]: v, [this.props.valueKey]: v };
+        if (!existingOptions[v]) {
+          this.props.options.unshift(opt);
+        }
+        return opt;
+      }),
+    );
+    if (options.length) {
+      if (this.props.onChange) {
+        this.props.onChange(options);
+      }
+    }
+  }
+  render() {
+    const SelectComponent = this.props.selectWrap;
+    const refFunc = (ref) => {
+      if (this.props.ref) {
+        this.props.ref(ref);
+      }
+      this.pasteInput = ref;
+    };
+    const inputProps = { onPaste: this.onPaste.bind(this) };
+    return (
+      <SelectComponent
+        {...this.props}
+        ref={refFunc}
+        inputProps={inputProps}
+      />
+    );
+  }
+}
+
+OnPasteSelect.propTypes = {
+  separator: PropTypes.string.isRequired,
+  selectWrap: PropTypes.func.isRequired,
+  ref: PropTypes.func,
+  onChange: PropTypes.func.isRequired,
+  valueKey: PropTypes.string.isRequired,
+  labelKey: PropTypes.string.isRequired,
+  options: PropTypes.array,
+  multi: PropTypes.bool.isRequired,
+  value: PropTypes.any,
+  isValidNewOption: PropTypes.func,
+};
+OnPasteSelect.defaultProps = {
+  separator: ',',
+  selectWrap: Select,
+  valueKey: 'value',
+  labelKey: 'label',
+  options: [],
+  multi: false,
+};
diff --git a/superset/assets/javascripts/components/VirtualizedRendererWrap.jsx b/superset/assets/javascripts/components/VirtualizedRendererWrap.jsx
new file mode 100644
index 0000000000000..32821124bd19b
--- /dev/null
+++ b/superset/assets/javascripts/components/VirtualizedRendererWrap.jsx
@@ -0,0 +1,56 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+export default function VirtualizedRendererWrap(renderer) {
+  function WrapperRenderer({
+    focusedOption,
+    focusOption,
+    key,
+    option,
+    selectValue,
+    style,
+    valueArray,
+  }) {
+    if (!option) {
+      return null;
+    }
+    const className = ['VirtualizedSelectOption'];
+    if (option === focusedOption) {
+      className.push('VirtualizedSelectFocusedOption');
+    }
+    if (option.disabled) {
+      className.push('VirtualizedSelectDisabledOption');
+    }
+    if (valueArray && valueArray.indexOf(option) >= 0) {
+      className.push('VirtualizedSelectSelectedOption');
+    }
+    if (option.className) {
+      className.push(option.className);
+    }
+    const events = option.disabled ? {} : {
+      onClick: () => selectValue(option),
+      onMouseEnter: () => focusOption(option),
+    };
+    return (
+      <div
+        className={className.join(' ')}
+        key={key}
+        style={Object.assign(option.style || {}, style)}
+        title={option.title}
+        {...events}
+      >
+        {renderer(option)}
+      </div>
+    );
+  }
+  WrapperRenderer.propTypes = {
+    focusedOption: PropTypes.object.isRequired,
+    focusOption: PropTypes.func.isRequired,
+    key: PropTypes.string,
+    option: PropTypes.object,
+    selectValue: PropTypes.func.isRequired,
+    style: PropTypes.object,
+    valueArray: PropTypes.array,
+  };
+  return WrapperRenderer;
+}
diff --git a/superset/assets/javascripts/explore/components/controls/SelectControl.jsx b/superset/assets/javascripts/explore/components/controls/SelectControl.jsx
index 51381d64d63dd..a82995d70e4fa 100644
--- a/superset/assets/javascripts/explore/components/controls/SelectControl.jsx
+++ b/superset/assets/javascripts/explore/components/controls/SelectControl.jsx
@@ -1,8 +1,11 @@
 import React from 'react';
 import PropTypes from 'prop-types';
+import VirtualizedSelect from 'react-virtualized-select';
 import Select, { Creatable } from 'react-select';
 import ControlHeader from '../ControlHeader';
 import { t } from '../../../locales';
+import VirtualizedRendererWrap from '../../../components/VirtualizedRendererWrap';
+import OnPasteSelect from '../../../components/OnPasteSelect';
 
 const propTypes = {
   choices: PropTypes.array,
@@ -37,55 +40,6 @@ const defaultProps = {
   valueKey: 'value',
 };
 
-// Handle `onPaste` so that users may paste in
-// options as comma-delimited, slightly modified from
-// https://github.com/JedWatson/react-select/issues/1672
-function pasteSelect(props) {
-  let pasteInput;
-  return (
-    <Select
-      {...props}
-      ref={(ref) => {
-        // Creatable requires a reference to its Select child
-        if (props.ref) {
-          props.ref(ref);
-        }
-        pasteInput = ref;
-      }}
-      inputProps={{
-        onPaste: (evt) => {
-          if (!props.multi) {
-            return;
-          }
-          evt.preventDefault();
-          // pull text from the clipboard and split by comma
-          const clipboard = evt.clipboardData.getData('Text');
-          if (!clipboard) {
-            return;
-          }
-          const values = clipboard.split(/[,]+/).map(v => v.trim());
-          const options = values
-            .filter(value =>
-              // Creatable validates options
-              props.isValidNewOption ? props.isValidNewOption({ label: value }) : !!value,
-            )
-            .map(value => ({
-              [props.labelKey]: value,
-              [props.valueKey]: value,
-            }));
-          if (options.length) {
-            pasteInput.selectValue(options);
-          }
-        },
-      }}
-    />
-  );
-}
-pasteSelect.propTypes = {
-  multi: PropTypes.bool,
-  ref: PropTypes.func,
-};
-
 export default class SelectControl extends React.PureComponent {
   constructor(props) {
     super(props);
@@ -161,23 +115,16 @@ export default class SelectControl extends React.PureComponent {
       clearable: this.props.clearable,
       isLoading: this.props.isLoading,
       onChange: this.onChange,
-      optionRenderer: this.props.optionRenderer,
+      optionRenderer: VirtualizedRendererWrap(this.props.optionRenderer),
       valueRenderer: this.props.valueRenderer,
+      selectComponent: this.props.freeForm ? Creatable : Select,
     };
-    //  Tab, comma or Enter will trigger a new option created for FreeFormSelect
-    const selectWrap = this.props.freeForm ? (
-      <Creatable {...selectProps}>
-        {pasteSelect}
-      </Creatable>
-    ) : (
-      pasteSelect(selectProps)
-    );
     return (
       <div>
         {this.props.showHeader &&
           <ControlHeader {...this.props} />
         }
-        {selectWrap}
+        <OnPasteSelect {...selectProps} selectWrap={VirtualizedSelect} />
       </div>
     );
   }
diff --git a/superset/assets/javascripts/explore/stores/controls.jsx b/superset/assets/javascripts/explore/stores/controls.jsx
index fa92cd5c66df9..e3da06b621bd7 100644
--- a/superset/assets/javascripts/explore/stores/controls.jsx
+++ b/superset/assets/javascripts/explore/stores/controls.jsx
@@ -568,17 +568,28 @@ export const controls = {
   granularity_sqla: {
     type: 'SelectControl',
     label: t('Time Column'),
-    default: control =>
-      control.choices && control.choices.length > 0 ? control.choices[0][0] : null,
     description: t('The time column for the visualization. Note that you ' +
     'can define arbitrary expression that return a DATETIME ' +
-    'column in the table or. Also note that the ' +
+    'column in the table. Also note that the ' +
     'filter below is applied against this column or ' +
     'expression'),
-    mapStateToProps: state => ({
-      choices: (state.datasource) ? state.datasource.granularity_sqla : [],
-    }),
-    freeForm: true,
+    default: (c) => {
+      if (c.options && c.options.length > 0) {
+        return c.options[0].column_name;
+      }
+      return null;
+    },
+    clearable: false,
+    optionRenderer: c => <ColumnOption column={c} />,
+    valueRenderer: c => <ColumnOption column={c} />,
+    valueKey: 'column_name',
+    mapStateToProps: (state) => {
+      const newState = {};
+      if (state.datasource) {
+        newState.options = state.datasource.columns.filter(c => c.is_dttm);
+      }
+      return newState;
+    },
   },
 
   time_grain_sqla: {
diff --git a/superset/assets/spec/javascripts/components/OnPasteSelect_spec.jsx b/superset/assets/spec/javascripts/components/OnPasteSelect_spec.jsx
new file mode 100644
index 0000000000000..949ca03f3b683
--- /dev/null
+++ b/superset/assets/spec/javascripts/components/OnPasteSelect_spec.jsx
@@ -0,0 +1,105 @@
+/* eslint-disable no-unused-expressions */
+import React from 'react';
+import sinon from 'sinon';
+import { expect } from 'chai';
+import { shallow } from 'enzyme';
+import { describe, it } from 'mocha';
+import VirtualizedSelect from 'react-virtualized-select';
+import Select, { Creatable } from 'react-select';
+
+import OnPasteSelect from '../../../javascripts/components/OnPasteSelect';
+
+const defaultProps = {
+  onChange: sinon.spy(),
+  multi: true,
+  isValidNewOption: sinon.spy(s => !!s.label),
+  value: [],
+  options: [
+    { value: 'United States', label: 'United States' },
+    { value: 'China', label: 'China' },
+    { value: 'India', label: 'India' },
+    { value: 'Canada', label: 'Canada' },
+    { value: 'Russian Federation', label: 'Russian Federation' },
+    { value: 'Japan', label: 'Japan' },
+    { value: 'Mexico', label: 'Mexico' },
+  ],
+};
+
+const defaultEvt = {
+  preventDefault: sinon.spy(),
+  clipboardData: {
+    getData: sinon.spy(() => ' United States, China  , India, Canada, '),
+  },
+};
+
+describe('OnPasteSelect', () => {
+  let wrapper;
+  let props;
+  let evt;
+  let expected;
+  beforeEach(() => {
+    props = Object.assign({}, defaultProps);
+    wrapper = shallow(<OnPasteSelect {...props} />);
+    evt = Object.assign({}, defaultEvt);
+  });
+
+  it('renders the supplied selectWrap component', () => {
+    const select = wrapper.find(Select);
+    expect(select).to.have.lengthOf(1);
+  });
+
+  it('renders custom selectWrap components', () => {
+    props.selectWrap = Creatable;
+    wrapper = shallow(<OnPasteSelect {...props} />);
+    expect(wrapper.find(Creatable)).to.have.lengthOf(1);
+    props.selectWrap = VirtualizedSelect;
+    wrapper = shallow(<OnPasteSelect {...props} />);
+    expect(wrapper.find(VirtualizedSelect)).to.have.lengthOf(1);
+  });
+
+  describe('onPaste', () => {
+    it('calls onChange with pasted values', () => {
+      wrapper.instance().onPaste(evt);
+      expected = props.options.slice(0, 4);
+      expect(props.onChange.calledWith(expected)).to.be.true;
+      expect(evt.preventDefault.called).to.be.true;
+      expect(props.isValidNewOption.callCount).to.equal(5);
+    });
+
+    it('calls onChange without any duplicate values and adds new values', () => {
+      evt.clipboardData.getData = sinon.spy(() =>
+        'China, China, China, China, Mexico, Mexico, Chi na, Mexico, ',
+      );
+      expected = [
+        props.options[1],
+        props.options[6],
+        { label: 'Chi na', value: 'Chi na' },
+      ];
+      wrapper.instance().onPaste(evt);
+      expect(props.onChange.calledWith(expected)).to.be.true;
+      expect(evt.preventDefault.called).to.be.true;
+      expect(props.isValidNewOption.callCount).to.equal(9);
+      expect(props.options[0].value).to.equal(expected[2].value);
+      props.options.splice(0, 1);
+    });
+
+    it('calls onChange with currently selected values and new values', () => {
+      props.value = ['United States', 'Canada', 'Mexico'];
+      evt.clipboardData.getData = sinon.spy(() =>
+        'United States, Canada, Japan, India',
+      );
+      wrapper = shallow(<OnPasteSelect {...props} />);
+      expected = [
+        props.options[0],
+        props.options[3],
+        props.options[6],
+        props.options[5],
+        props.options[2],
+      ];
+      wrapper.instance().onPaste(evt);
+      expect(props.onChange.calledWith(expected)).to.be.true;
+      expect(evt.preventDefault.called).to.be.true;
+      expect(props.isValidNewOption.callCount).to.equal(11);
+    });
+  });
+});
diff --git a/superset/assets/spec/javascripts/components/VirtualizedRendererWrap_spec.jsx b/superset/assets/spec/javascripts/components/VirtualizedRendererWrap_spec.jsx
new file mode 100644
index 0000000000000..1cd4c4e9c00a3
--- /dev/null
+++ b/superset/assets/spec/javascripts/components/VirtualizedRendererWrap_spec.jsx
@@ -0,0 +1,106 @@
+/* eslint-disable no-unused-expressions */
+import React from 'react';
+import sinon from 'sinon';
+import PropTypes from 'prop-types';
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { shallow } from 'enzyme';
+
+import VirtualizedRendererWrap from '../../../javascripts/components/VirtualizedRendererWrap';
+
+const defaultProps = {
+  focusedOption: { label: 'focusedOn', value: 'focusedOn' },
+  focusOption: sinon.spy(),
+  key: 'key1',
+  option: { label: 'option1', value: 'option1' },
+  selectValue: sinon.spy(),
+  valueArray: [],
+};
+
+function TestOption({ option }) {
+  return (
+    <span>{option.label}</span>
+  );
+}
+TestOption.propTypes = {
+  option: PropTypes.object.isRequired,
+};
+
+const defaultRenderer = opt => <TestOption option={opt} />;
+const RendererWrap = VirtualizedRendererWrap(defaultRenderer);
+
+describe('VirtualizedRendererWrap', () => {
+  let wrapper;
+  let props;
+  beforeEach(() => {
+    wrapper = shallow(<RendererWrap {...defaultProps} />);
+    props = Object.assign({}, defaultProps);
+  });
+
+  it('uses the provided renderer', () => {
+    const option = wrapper.find(TestOption);
+    expect(option).to.have.lengthOf(1);
+  });
+
+  it('renders nothing when no option is provided', () => {
+    props.option = null;
+    wrapper = shallow(<RendererWrap {...props} />);
+    const option = wrapper.find(TestOption);
+    expect(option).to.have.lengthOf(0);
+  });
+
+  it('renders unfocused, unselected options with the default class', () => {
+    const optionDiv = wrapper.find('div');
+    expect(optionDiv).to.have.lengthOf(1);
+    expect(optionDiv.props().className).to.equal('VirtualizedSelectOption');
+  });
+
+  it('renders focused option with the correct class', () => {
+    props.option = props.focusedOption;
+    wrapper = shallow(<RendererWrap {...props} />);
+    const optionDiv = wrapper.find('div');
+    expect(optionDiv.props().className).to.equal(
+      'VirtualizedSelectOption VirtualizedSelectFocusedOption',
+    );
+  });
+
+  it('renders disabled option with the correct class', () => {
+    props.option.disabled = true;
+    wrapper = shallow(<RendererWrap {...props} />);
+    const optionDiv = wrapper.find('div');
+    expect(optionDiv.props().className).to.equal(
+      'VirtualizedSelectOption VirtualizedSelectDisabledOption',
+    );
+    props.option.disabled = false;
+  });
+
+  it('renders selected option with the correct class', () => {
+    props.valueArray = [props.option, props.focusedOption];
+    wrapper = shallow(<RendererWrap {...props} />);
+    const optionDiv = wrapper.find('div');
+    expect(optionDiv.props().className).to.equal(
+      'VirtualizedSelectOption VirtualizedSelectSelectedOption',
+    );
+  });
+
+  it('renders options with custom classes', () => {
+    props.option.className = 'CustomClass';
+    wrapper = shallow(<RendererWrap {...props} />);
+    const optionDiv = wrapper.find('div');
+    expect(optionDiv.props().className).to.equal(
+      'VirtualizedSelectOption CustomClass',
+    );
+  });
+
+  it('calls focusedOption on its own option onMouseEnter', () => {
+    const optionDiv = wrapper.find('div');
+    optionDiv.simulate('mouseEnter');
+    expect(props.focusOption.calledWith(props.option)).to.be.true;
+  });
+
+  it('calls selectValue on its own option onClick', () => {
+    const optionDiv = wrapper.find('div');
+    optionDiv.simulate('click');
+    expect(props.selectValue.calledWith(props.option)).to.be.true;
+  });
+});
diff --git a/superset/assets/spec/javascripts/explore/components/SelectControl_spec.jsx b/superset/assets/spec/javascripts/explore/components/SelectControl_spec.jsx
index 7508eebd41463..d0eea9c801d64 100644
--- a/superset/assets/spec/javascripts/explore/components/SelectControl_spec.jsx
+++ b/superset/assets/spec/javascripts/explore/components/SelectControl_spec.jsx
@@ -1,10 +1,13 @@
 /* eslint-disable no-unused-expressions */
 import React from 'react';
 import Select, { Creatable } from 'react-select';
+import VirtualizedSelect from 'react-virtualized-select';
 import sinon from 'sinon';
 import { expect } from 'chai';
 import { describe, it, beforeEach } from 'mocha';
 import { shallow } from 'enzyme';
+import OnPasteSelect from '../../../../javascripts/components/OnPasteSelect';
+import VirtualizedRendererWrap from '../../../../javascripts/components/VirtualizedRendererWrap';
 import SelectControl from '../../../../javascripts/explore/components/controls/SelectControl';
 
 const defaultProps = {
@@ -26,19 +29,39 @@ describe('SelectControl', () => {
     wrapper = shallow(<SelectControl {...defaultProps} />);
   });
 
-  it('renders a Select', () => {
-    expect(wrapper.find(Select)).to.have.lengthOf(1);
+  it('renders an OnPasteSelect', () => {
+    expect(wrapper.find(OnPasteSelect)).to.have.lengthOf(1);
   });
 
   it('calls onChange when toggled', () => {
-    const select = wrapper.find(Select);
+    const select = wrapper.find(OnPasteSelect);
     select.simulate('change', { value: 50 });
     expect(defaultProps.onChange.calledWith(50)).to.be.true;
   });
 
-  it('renders a Creatable for freeform', () => {
+  it('passes VirtualizedSelect as selectWrap', () => {
+    const select = wrapper.find(OnPasteSelect);
+    expect(select.props().selectWrap).to.equal(VirtualizedSelect);
+  });
+
+  it('passes Creatable as selectComponent when freeForm=true', () => {
     wrapper = shallow(<SelectControl {...defaultProps} freeForm />);
-    expect(wrapper.find(Creatable)).to.have.lengthOf(1);
+    const select = wrapper.find(OnPasteSelect);
+    expect(select.props().selectComponent).to.equal(Creatable);
+  });
+
+  it('passes Select as selectComponent when freeForm=false', () => {
+    const select = wrapper.find(OnPasteSelect);
+    expect(select.props().selectComponent).to.equal(Select);
+  });
+
+  it('wraps optionRenderer in a VirtualizedRendererWrap', () => {
+    const select = wrapper.find(OnPasteSelect);
+    const defaultOptionRenderer = SelectControl.defaultProps.optionRenderer;
+    const wrappedRenderer = VirtualizedRendererWrap(defaultOptionRenderer);
+    expect(select.props().optionRenderer).to.be.a('Function');
+    // different instances of wrapper with same inner renderer are unequal
+    expect(select.props().optionRenderer.name).to.equal(wrappedRenderer.name);
   });
 
   describe('getOptions', () => {
diff --git a/superset/assets/visualizations/filter_box.jsx b/superset/assets/visualizations/filter_box.jsx
index d09755a6eda45..bdcf978d3df2a 100644
--- a/superset/assets/visualizations/filter_box.jsx
+++ b/superset/assets/visualizations/filter_box.jsx
@@ -3,13 +3,16 @@ import d3 from 'd3';
 import React from 'react';
 import PropTypes from 'prop-types';
 import ReactDOM from 'react-dom';
-import Select from 'react-select';
+import VirtualizedSelect from 'react-virtualized-select';
+import { Creatable } from 'react-select';
 import { Button } from 'react-bootstrap';
 
 import DateFilterControl from '../javascripts/explore/components/controls/DateFilterControl';
 import ControlRow from '../javascripts/explore/components/ControlRow';
 import Control from '../javascripts/explore/components/Control';
 import controls from '../javascripts/explore/stores/controls';
+import OnPasteSelect from '../javascripts/components/OnPasteSelect';
+import VirtualizedRendererWrap from '../javascripts/components/VirtualizedRendererWrap';
 import './filter_box.css';
 import { t } from '../javascripts/locales';
 
@@ -164,7 +167,7 @@ class FilterBox extends React.Component {
             text: v,
             metric: 0,
           };
-          this.props.filtersChoices[filterKey].push(addChoice);
+          this.props.filtersChoices[filterKey].unshift(addChoice);
         }
       }
     }
@@ -177,7 +180,7 @@ class FilterBox extends React.Component {
       return (
         <div key={filter} className="m-b-5">
           {this.props.datasource.verbose_map[filter] || filter}
-          <Select.Creatable
+          <OnPasteSelect
             placeholder={t('Select [%s]', filter)}
             key={filter}
             multi
@@ -195,6 +198,9 @@ class FilterBox extends React.Component {
               return { value: opt.id, label: opt.id, style };
             })}
             onChange={this.changeFilter.bind(this, filter)}
+            selectComponent={Creatable}
+            selectWrap={VirtualizedSelect}
+            optionRenderer={VirtualizedRendererWrap(opt => opt.label)}
           />
         </div>
       );
diff --git a/superset/connectors/base/models.py b/superset/connectors/base/models.py
index bf66c606842e3..4f3dab093062e 100644
--- a/superset/connectors/base/models.py
+++ b/superset/connectors/base/models.py
@@ -209,6 +209,7 @@ class BaseColumn(AuditMixinNullable, ImportMixin):
     min = Column(Boolean, default=False)
     filterable = Column(Boolean, default=False)
     description = Column(Text)
+    is_dttm = None
 
     # [optional] Set this to support import/export functionality
     export_fields = []
@@ -252,7 +253,7 @@ def expression(self):
     def data(self):
         attrs = (
             'column_name', 'verbose_name', 'description', 'expression',
-            'filterable', 'groupby')
+            'filterable', 'groupby', 'is_dttm')
         return {s: getattr(self, s) for s in attrs}
 
 
diff --git a/superset/db_engine_specs.py b/superset/db_engine_specs.py
index c5363af2b2c8a..d37096ac374b0 100644
--- a/superset/db_engine_specs.py
+++ b/superset/db_engine_specs.py
@@ -198,15 +198,16 @@ def modify_url_for_impersonation(cls, url, impersonate_user, username):
             url.username = username
 
     @classmethod
-    def get_uri_for_impersonation(cls, uri, impersonate_user, username):
+    def get_configuration_for_impersonation(cls, uri, impersonate_user, username):
         """
-        Return a new URI string that allows for user impersonation.
+        Return a configuration dictionary that can be merged with other configs
+        that can set the correct properties for impersonating users
         :param uri: URI string
-        :param impersonate_user:  Bool indicating if impersonation is enabled
+        :param impersonate_user: Bool indicating if impersonation is enabled
         :param username: Effective username
-        :return: New URI string
+        :return: Dictionary with configs required for impersonation
         """
-        return uri
+        return {}
 
 
 class PostgresEngineSpec(BaseEngineSpec):
@@ -701,7 +702,6 @@ def patch(cls):
         hive.constants = patched_constants
         hive.ttypes = patched_ttypes
         hive.Cursor.fetch_logs = patched_hive.fetch_logs
-        hive.Connection = patched_hive.ConnectionProxyUser
 
     @classmethod
     @cache_util.memoized_func(
@@ -863,27 +863,29 @@ def modify_url_for_impersonation(cls, url, impersonate_user, username):
         :param impersonate_user: Bool indicating if impersonation is enabled
         :param username: Effective username
         """
-        if impersonate_user is not None and "auth" in url.query.keys() and username is not None:
-            url.query["hive_server2_proxy_user"] = username
+        # Do nothing in the URL object since instead this should modify
+        # the configuraiton dictionary. See get_configuration_for_impersonation
+        pass
 
     @classmethod
-    def get_uri_for_impersonation(cls, uri, impersonate_user, username):
+    def get_configuration_for_impersonation(cls, uri, impersonate_user, username):
         """
-        Return a new URI string that allows for user impersonation.
+        Return a configuration dictionary that can be merged with other configs
+        that can set the correct properties for impersonating users
         :param uri: URI string
-        :param impersonate_user:  Bool indicating if impersonation is enabled
+        :param impersonate_user: Bool indicating if impersonation is enabled
         :param username: Effective username
-        :return: New URI string
+        :return: Dictionary with configs required for impersonation
         """
-        new_uri = uri
+        configuration = {}
         url = make_url(uri)
         backend_name = url.get_backend_name()
 
         # Must be Hive connection, enable impersonation, and set param auth=LDAP|KERBEROS
-        if backend_name == "hive" and "auth" in url.query.keys() and\
+        if backend_name == "hive" and "auth" in url.query.keys() and \
                         impersonate_user is True and username is not None:
-            new_uri += "&hive_server2_proxy_user={0}".format(username)
-        return new_uri
+            configuration["hive.server2.proxy.user"] = username
+        return configuration
 
 class MssqlEngineSpec(BaseEngineSpec):
     engine = 'mssql'
diff --git a/superset/db_engines/hive.py b/superset/db_engines/hive.py
index 334ae0a4b2d87..bf3566fac11ec 100644
--- a/superset/db_engines/hive.py
+++ b/superset/db_engines/hive.py
@@ -3,27 +3,6 @@
 from thrift import Thrift
 
 
-old_Connection = hive.Connection
-
-# TODO
-# Monkey-patch of PyHive project's pyhive/hive.py which needed to change the constructor.
-# Submitted a pull request on October 13, 2017 and waiting for it to be merged.
-# https://github.com/dropbox/PyHive/pull/165
-class ConnectionProxyUser(hive.Connection):
-
-    def __init__(self, host=None, port=None, username=None, database='default', auth=None,
-             configuration=None, kerberos_service_name=None, password=None,
-             thrift_transport=None, hive_server2_proxy_user=None):
-        configuration = configuration or {}
-        if auth is not None and auth in ('LDAP', 'KERBEROS'):
-            if hive_server2_proxy_user is not None:
-                configuration["hive.server2.proxy.user"] = hive_server2_proxy_user
-        # restore the old connection class, otherwise, will recurse on its own __init__ method
-        hive.Connection = old_Connection
-        hive.Connection.__init__(self, host=host, port=port, username=username, database=database, auth=auth,
-                 configuration=configuration, kerberos_service_name=kerberos_service_name, password=password,
-                 thrift_transport=thrift_transport)
-
 
 # TODO: contribute back to pyhive.
 def fetch_logs(self, max_rows=1024,
diff --git a/superset/models/core.py b/superset/models/core.py
index aa2484fdb48b3..78a72a7487612 100644
--- a/superset/models/core.py
+++ b/superset/models/core.py
@@ -620,23 +620,35 @@ def get_effective_user(self, url, user_name=None):
             effective_username = url.username
             if user_name:
                 effective_username = user_name
-            elif hasattr(g, 'user') and g.user.username:
+            elif hasattr(g, 'user') and hasattr(g.user, 'username') and g.user.username is not None:
                 effective_username = g.user.username
         return effective_username
 
     def get_sqla_engine(self, schema=None, nullpool=False, user_name=None):
         extra = self.get_extra()
         url = make_url(self.sqlalchemy_uri_decrypted)
-        params = extra.get('engine_params', {})
-        if nullpool:
-            params['poolclass'] = NullPool
         url = self.db_engine_spec.adjust_database_uri(url, schema)
         effective_username = self.get_effective_user(url, user_name)
+        # If using MySQL or Presto for example, will set url.username
+        # If using Hive, will not do anything yet since that relies on a configuration parameter instead.
         self.db_engine_spec.modify_url_for_impersonation(url, self.impersonate_user, effective_username)
 
         masked_url = self.get_password_masked_url(url)
         logging.info("Database.get_sqla_engine(). Masked URL: {0}".format(masked_url))
 
+        params = extra.get('engine_params', {})
+        if nullpool:
+            params['poolclass'] = NullPool
+
+        # If using Hive, this will set hive.server2.proxy.user=$effective_username
+        configuration = {}
+        configuration.update(
+            self.db_engine_spec.get_configuration_for_impersonation(str(url),
+                                                                    self.impersonate_user,
+                                                                    effective_username))
+        if configuration:
+            params["connect_args"] = {"configuration": configuration}
+        
         return create_engine(url, **params)
 
     def get_reserved_words(self):
diff --git a/superset/views/core.py b/superset/views/core.py
index a0273713dfa69..7c60f86aba7ab 100755
--- a/superset/views/core.py
+++ b/superset/views/core.py
@@ -1433,6 +1433,7 @@ def testconn(self):
             uri = request.json.get('uri')
             db_name = request.json.get('name')
             impersonate_user = request.json.get('impersonate_user')
+            database = None
             if db_name:
                 database = (
                     db.session
@@ -1445,19 +1446,31 @@ def testconn(self):
                     # use the URI associated with this database
                     uri = database.sqlalchemy_uri_decrypted
 
-            url = make_url(uri)
-            db_engine = models.Database.get_db_engine_spec_for_backend(url.get_backend_name())
-            db_engine.patch()
-            uri = db_engine.get_uri_for_impersonation(uri, impersonate_user, username)
-            masked_url = database.get_password_masked_url_from_uri(uri)
+            configuration = {}
 
-            logging.info("Superset.testconn(). Masked URL: {0}".format(masked_url))
+            if database and uri:
+                url = make_url(uri)
+                db_engine = models.Database.get_db_engine_spec_for_backend(url.get_backend_name())
+                db_engine.patch()
+            
+                masked_url = database.get_password_masked_url_from_uri(uri)
+                logging.info("Superset.testconn(). Masked URL: {0}".format(masked_url))
+
+                configuration.update(
+                    db_engine.get_configuration_for_impersonation(uri,
+                                                                  impersonate_user,
+                                                                  username)
+                )
 
             connect_args = (
                 request.json
                 .get('extras', {})
                 .get('engine_params', {})
                 .get('connect_args', {}))
+
+            if configuration:
+                connect_args["configuration"] = configuration
+
             engine = create_engine(uri, connect_args=connect_args)
             engine.connect()
             return json_success(json.dumps(engine.table_names(), indent=4))
diff --git a/tests/core_tests.py b/tests/core_tests.py
index 8caaeb0827f68..7d1b2fd1ca4b1 100644
--- a/tests/core_tests.py
+++ b/tests/core_tests.py
@@ -143,7 +143,6 @@ def test_save_slice(self):
 
         form_data = {
             'viz_type': 'sankey',
-            'groupby': 'source',
             'groupby': 'target',
             'metric': 'sum__value',
             'row_limit': 5000,
@@ -165,7 +164,6 @@ def test_save_slice(self):
 
         form_data = {
             'viz_type': 'sankey',
-            'groupby': 'source',
             'groupby': 'target',
             'metric': 'sum__value',
             'row_limit': 5000,
diff --git a/tox.ini b/tox.ini
index ea9ff5fbf80e3..f3420a5f2c765 100644
--- a/tox.ini
+++ b/tox.ini
@@ -45,7 +45,6 @@ ignore =
     F401
     F403
     F405
-    F601
     I100
     I101
     I201