Select impl by dialect.
8054
def load_dialect_impl(self, dialect):  # type: (DefaultDialect) -> TypeEngine
        """"""
        if self.__use_json(dialect):
            return dialect.type_descriptor(self.__json_type)
        return dialect.type_descriptor(sqlalchemy.UnicodeText)
138557
def get_abbr_impl(env):
    """"""
    impl = env.python_implementation

    if impl == "PyPy":
        return "pp"
    elif impl == "Jython":
        return "jy"
    elif impl == "IronPython":
        return "ip"
    elif impl == "CPython":
        return "cp"

    raise LookupError("Unknown Python implementation: " + impl)
1228267
public static Dialect getDialect(DataSource ds) {
		Dialect dialect = dialectPool.get(ds);
		if(null == dialect) {
			synchronized (lock) {
				dialect = dialectPool.get(ds);
				if(null == dialect) {
					dialect = newDialect(ds);
					dialectPool.put(ds, dialect);
				}
			}
		}
		return dialect;
	}
1159894
def get_abbr_impl():
    # type: () -> str
    """"""
    if hasattr(sys, 'pypy_version_info'):
        pyimpl = 'pp'
    elif sys.platform.startswith('java'):
        pyimpl = 'jy'
    elif sys.platform == 'cli':
        pyimpl = 'ip'
    else:
        pyimpl = 'cp'
    return pyimpl
636456
def lang_items(self, lang=None):
        """"""
        if lang is None:
            lang = self.language
        yield from self.cache.setdefault(lang, {}).items()
998179
def selectis(table, field, value, complement=False):
    """"""

    return selectop(table, field, value, operator.is_, complement=complement)
1043700
def _dialect(self, filepath):
        
        with open(filepath, self.read_mode) as csvfile:
            sample = csvfile.read(1024)
            dialect = csv.Sniffer().sniff(sample)
            if self.has_header == None:
                # detect header if header not specified
                self.has_header = csv.Sniffer().has_header(sample)
            csvfile.seek(0)
        return dialect
294091
def process_bind_param(self, value: Optional[List[str]],
                           dialect: Dialect) -> str:
        """"""
        retval = self._strlist_to_dbstr(value)
        return retval
606594
def dialect_compare(dialect1, dialect2):
    
    orig = set(dialect1.items())
    new = set(dialect2.items())
    return dict(
        added=dict(list(new.difference(orig))),
        removed=dict(list(orig.difference(new)))
    )
62026
def selecttrue(table, field, complement=False):
    """"""

    return select(table, field, lambda v: bool(v), complement=complement)
1332577
def sql(self, dialect=None, inserts=False, creates=True,
            drops=True, metadata_source=None):
        
        result = [self.ddl(dialect, creates=creates, drops=drops)]
        if inserts:
            for row in self.inserts(dialect):
                result.append(row)
        return '\n'.join(result)
931160
def filter(select, iterable, namespaces=None, flags=0, **kwargs):  # noqa: A001
    """"""

    return compile(select, namespaces, flags, **kwargs).filter(iterable)
828554
def get_dialect(mixed: Union[SQLCompiler, Engine, Dialect]) -> Dialect:
    
    if isinstance(mixed, Dialect):
        return mixed
    elif isinstance(mixed, Engine):
        return mixed.dialect
    elif isinstance(mixed, SQLCompiler):
        return mixed.dialect
    else:
        raise ValueError("get_dialect: 'mixed' parameter of wrong type")
431137
def dialect(self):
        
        if self._dialect is None:
            self._dialect = model.DIALECT_DEFAULT
            if self.header:
                source = self.header.sub_tag("SOUR")
                if source:
                    if source.value == "MYHERITAGE":
                        self._dialect = model.DIALECT_MYHERITAGE
                    elif source.value == "ALTREE":
                        self._dialect = model.DIALECT_ALTREE
                    elif source.value == "ANCESTRIS":
                        self._dialect = model.DIALECT_ANCESTRIS
        return self._dialect
324717
def process_result_value(self, value, dialect):
        
        if value is not None:
            cmd = "value = {}".format(value)
            exec(cmd)
        return value
1227164
def process_literal_param(self, value: Optional[List[int]],
                              dialect: Dialect) -> str:
        """"""
        retval = self._intlist_to_dbstr(value)
        return retval
718382
def compile_select(self, query):
        
        sql = super(MySqlQueryGrammar, self).compile_select(query)

        if query.unions:
            sql = '(%s) %s' % (sql, self._compile_unions(query))

        return sql