sqlalchemy-cratedb 0.38.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

sqlalchemy_cratedb/compiler.py

@@ -24,17 +24,18 @@ import warnings
 from collections import defaultdict
 
 import sqlalchemy as sa
-from sqlalchemy.dialects.postgresql.base import PGCompiler
 from sqlalchemy.dialects.postgresql.base import RESERVED_WORDS as POSTGRESQL_RESERVED_WORDS
+from sqlalchemy.dialects.postgresql.base import PGCompiler
 from sqlalchemy.sql import compiler
 from sqlalchemy.types import String
+
+from .sa_version import SA_1_4, SA_VERSION
 from .type.geo import Geopoint, Geoshape
 from .type.object import MutableDict, ObjectTypeImpl
-from .sa_version import SA_VERSION, SA_1_4
 
 
 def rewrite_update(clauseelement, multiparams, params):
-    """ change the params to enable partial updates
+    """change the params to enable partial updates
 
     sqlalchemy by default only supports updates of complex types in the form of
 
@@ -55,9 +56,8 @@ def rewrite_update(clauseelement, multiparams, params):
     for _params in _multiparams:
         newparams = {}
         for key, val in _params.items():
-            if (
-                not isinstance(val, MutableDict) or
-                (not any(val._changed_keys) and not any(val._deleted_keys))
+            if not isinstance(val, MutableDict) or (
+                not any(val._changed_keys) and not any(val._deleted_keys)
             ):
                 newparams[key] = val
                 continue
@@ -68,7 +68,7 @@ def rewrite_update(clauseelement, multiparams, params):
             for subkey in val._deleted_keys:
                 newparams["{0}['{1}']".format(key, subkey)] = None
         newmultiparams.append(newparams)
-    _multiparams = (newmultiparams, )
+    _multiparams = (newmultiparams,)
     clause = clauseelement.values(newmultiparams[0])
     clause._crate_specific = True
     return clause, _multiparams, params
@@ -76,7 +76,7 @@ def rewrite_update(clauseelement, multiparams, params):
 
 @sa.event.listens_for(sa.engine.Engine, "before_execute", retval=True)
 def crate_before_execute(conn, clauseelement, multiparams, params, *args, **kwargs):
-    is_crate = type(conn.dialect).__name__ == 'CrateDialect'
+    is_crate = type(conn.dialect).__name__ == "CrateDialect"
     if is_crate and isinstance(clauseelement, sa.sql.expression.Update):
         if SA_VERSION >= SA_1_4:
             if params is None:
@@ -98,19 +98,19 @@ def crate_before_execute(conn, clauseelement, multiparams, params, *args, **kwar
 
 
 class CrateDDLCompiler(compiler.DDLCompiler):
-
-    __special_opts_tmpl = {
-        'partitioned_by': ' PARTITIONED BY ({0})'
-    }
+    __special_opts_tmpl = {"partitioned_by": " PARTITIONED BY ({0})"}
     __clustered_opts_tmpl = {
-        'number_of_shards': ' INTO {0} SHARDS',
-        'clustered_by': ' BY ({0})',
+        "number_of_shards": " INTO {0} SHARDS",
+        "clustered_by": " BY ({0})",
     }
-    __clustered_opt_tmpl = ' CLUSTERED{clustered_by}{number_of_shards}'
+    __clustered_opt_tmpl = " CLUSTERED{clustered_by}{number_of_shards}"
 
     def get_column_specification(self, column, **kwargs):
-        colspec = self.preparer.format_column(column) + " " + \
-            self.dialect.type_compiler.process(column.type)
+        colspec = (
+            self.preparer.format_column(column)
+            + " "
+            + self.dialect.type_compiler.process(column.type)
+        )
 
         default = self.get_column_default_string(column)
         if default is not None:
@@ -122,11 +122,9 @@ class CrateDDLCompiler(compiler.DDLCompiler):
         if column.nullable is False:
             colspec += " NOT NULL"
         elif column.nullable and column.primary_key:
-            raise sa.exc.CompileError(
-                "Primary key columns cannot be nullable"
-            )
+            raise sa.exc.CompileError("Primary key columns cannot be nullable")
 
-        if column.dialect_options['crate'].get('index') is False:
+        if column.dialect_options["crate"].get("index") is False:
             if isinstance(column.type, (Geopoint, Geoshape, ObjectTypeImpl)):
                 raise sa.exc.CompileError(
                     "Disabling indexing is not supported for column "
@@ -135,8 +133,8 @@ class CrateDDLCompiler(compiler.DDLCompiler):
 
             colspec += " INDEX OFF"
 
-        if column.dialect_options['crate'].get('columnstore') is False:
-            if not isinstance(column.type, (String, )):
+        if column.dialect_options["crate"].get("columnstore") is False:
+            if not isinstance(column.type, (String,)):
                 raise sa.exc.CompileError(
                     "Controlling the columnstore is only allowed for STRING columns"
                 )
@@ -148,8 +146,7 @@ class CrateDDLCompiler(compiler.DDLCompiler):
     def visit_computed_column(self, generated):
         if generated.persisted is False:
             raise sa.exc.CompileError(
-                "Virtual computed columns are not supported, set "
-                "'persisted' to None or True"
+                "Virtual computed columns are not supported, set " "'persisted' to None or True"
             )
 
         return "GENERATED ALWAYS AS (%s)" % self.sql_compiler.process(
@@ -157,14 +154,14 @@ class CrateDDLCompiler(compiler.DDLCompiler):
         )
 
     def post_create_table(self, table):
-        special_options = ''
+        special_options = ""
         clustered_options = defaultdict(str)
         table_opts = []
 
         opts = dict(
-            (k[len(self.dialect.name) + 1:], v)
-            for k, v, in table.kwargs.items()
-            if k.startswith('%s_' % self.dialect.name)
+            (k[len(self.dialect.name) + 1 :], v)
+            for k, v in table.kwargs.items()
+            if k.startswith("%s_" % self.dialect.name)
         )
         for k, v in opts.items():
             if k in self.__special_opts_tmpl:
@@ -172,69 +169,73 @@ class CrateDDLCompiler(compiler.DDLCompiler):
             elif k in self.__clustered_opts_tmpl:
                 clustered_options[k] = self.__clustered_opts_tmpl[k].format(v)
             else:
-                table_opts.append('{0} = {1}'.format(k, v))
+                table_opts.append("{0} = {1}".format(k, v))
         if clustered_options:
             special_options += string.Formatter().vformat(
-                self.__clustered_opt_tmpl, (), clustered_options)
+                self.__clustered_opt_tmpl, (), clustered_options
+            )
         if table_opts:
-            return special_options + ' WITH ({0})'.format(
-                ', '.join(sorted(table_opts)))
+            return special_options + " WITH ({0})".format(", ".join(sorted(table_opts)))
         return special_options
 
     def visit_foreign_key_constraint(self, constraint, **kw):
         """
         CrateDB does not support foreign key constraints.
         """
-        warnings.warn("CrateDB does not support foreign key constraints, "
-                      "they will be omitted when generating DDL statements.")
-        return None
+        warnings.warn(
+            "CrateDB does not support foreign key constraints, "
+            "they will be omitted when generating DDL statements.",
+            stacklevel=2,
+        )
+        return
 
     def visit_unique_constraint(self, constraint, **kw):
         """
         CrateDB does not support unique key constraints.
         """
-        warnings.warn("CrateDB does not support unique constraints, "
-                      "they will be omitted when generating DDL statements.")
-        return None
+        warnings.warn(
+            "CrateDB does not support unique constraints, "
+            "they will be omitted when generating DDL statements.",
+            stacklevel=2,
+        )
+        return
 
 
 class CrateTypeCompiler(compiler.GenericTypeCompiler):
-
     def visit_string(self, type_, **kw):
-        return 'STRING'
+        return "STRING"
 
     def visit_unicode(self, type_, **kw):
-        return 'STRING'
+        return "STRING"
 
     def visit_TEXT(self, type_, **kw):
-        return 'STRING'
+        return "STRING"
 
     def visit_DECIMAL(self, type_, **kw):
-        return 'DOUBLE'
+        return "DOUBLE"
 
     def visit_BIGINT(self, type_, **kw):
-        return 'LONG'
+        return "LONG"
 
     def visit_NUMERIC(self, type_, **kw):
-        return 'LONG'
+        return "LONG"
 
     def visit_INTEGER(self, type_, **kw):
-        return 'INT'
+        return "INT"
 
     def visit_SMALLINT(self, type_, **kw):
-        return 'SHORT'
+        return "SHORT"
 
     def visit_datetime(self, type_, **kw):
         return self.visit_TIMESTAMP(type_, **kw)
 
     def visit_date(self, type_, **kw):
-        return 'TIMESTAMP'
+        return "TIMESTAMP"
 
     def visit_ARRAY(self, type_, **kw):
         if type_.dimensions is not None and type_.dimensions > 1:
-            raise NotImplementedError(
-                "CrateDB doesn't support multidimensional arrays")
-        return 'ARRAY({0})'.format(self.process(type_.item_type))
+            raise NotImplementedError("CrateDB doesn't support multidimensional arrays")
+        return "ARRAY({0})".format(self.process(type_.item_type))
 
     def visit_OBJECT(self, type_, **kw):
         return "OBJECT"
@@ -251,32 +252,21 @@ class CrateTypeCompiler(compiler.GenericTypeCompiler):
 
         From `sqlalchemy.dialects.postgresql.base.PGTypeCompiler`.
         """
-        return "TIMESTAMP %s" % (
-            (type_.timezone and "WITH" or "WITHOUT") + " TIME ZONE",
-        )
+        return "TIMESTAMP %s" % ((type_.timezone and "WITH" or "WITHOUT") + " TIME ZONE",)
 
 
 class CrateCompiler(compiler.SQLCompiler):
-
     def visit_getitem_binary(self, binary, operator, **kw):
-        return "{0}['{1}']".format(
-            self.process(binary.left, **kw),
-            binary.right.value
-        )
+        return "{0}['{1}']".format(self.process(binary.left, **kw), binary.right.value)
 
-    def visit_json_getitem_op_binary(
-        self, binary, operator, _cast_applied=False, **kw
-    ):
-        return "{0}['{1}']".format(
-            self.process(binary.left, **kw),
-            binary.right.value
-        )
+    def visit_json_getitem_op_binary(self, binary, operator, _cast_applied=False, **kw):
+        return "{0}['{1}']".format(self.process(binary.left, **kw), binary.right.value)
 
     def visit_any(self, element, **kw):
         return "%s%sANY (%s)" % (
             self.process(element.left, **kw),
             compiler.OPERATORS[element.operator],
-            self.process(element.right, **kw)
+            self.process(element.right, **kw),
         )
 
     def visit_ilike_case_insensitive_operand(self, element, **kw):
@@ -331,29 +321,32 @@ class CrateCompiler(compiler.SQLCompiler):
     def for_update_clause(self, select, **kw):
         # CrateDB does not support the `INSERT ... FOR UPDATE` clause.
         # See https://github.com/crate/crate-python/issues/577.
-        warnings.warn("CrateDB does not support the 'INSERT ... FOR UPDATE' clause, "
-                      "it will be omitted when generating SQL statements.")
-        return ''
+        warnings.warn(
+            "CrateDB does not support the 'INSERT ... FOR UPDATE' clause, "
+            "it will be omitted when generating SQL statements.",
+            stacklevel=2,
+        )
+        return ""
 
 
-CRATEDB_RESERVED_WORDS = \
-    "add, alter, between, by, called, costs, delete, deny, directory, drop, escape, exists, " \
-    "extract, first, function, if, index, input, insert, last, match, nulls, object, " \
-    "persistent, recursive, reset, returns, revoke, set, stratify, transient, try_cast, " \
+CRATEDB_RESERVED_WORDS = (
+    "add, alter, between, by, called, costs, delete, deny, directory, drop, escape, exists, "
+    "extract, first, function, if, index, input, insert, last, match, nulls, object, "
+    "persistent, recursive, reset, returns, revoke, set, stratify, transient, try_cast, "
     "unbounded, update".split(", ")
+)
 
 
 class CrateIdentifierPreparer(sa.sql.compiler.IdentifierPreparer):
     """
     Define CrateDB's reserved words to be quoted properly.
     """
+
     reserved_words = set(list(POSTGRESQL_RESERVED_WORDS) + CRATEDB_RESERVED_WORDS)
 
     def _unquote_identifier(self, value):
         if value[0] == self.initial_quote:
-            value = value[1:-1].replace(
-                self.escape_to_quote, self.escape_quote
-            )
+            value = value[1:-1].replace(self.escape_to_quote, self.escape_quote)
         return value
 
     def format_type(self, type_, use_schema=True):
@@ -363,10 +356,6 @@ class CrateIdentifierPreparer(sa.sql.compiler.IdentifierPreparer):
         name = self.quote(type_.name)
         effective_schema = self.schema_for_object(type_)
 
-        if (
-            not self.omit_schema
-            and use_schema
-            and effective_schema is not None
-        ):
+        if not self.omit_schema and use_schema and effective_schema is not None:
             name = self.quote_schema(effective_schema) + "." + name
         return name

sqlalchemy_cratedb/dialect.py

@@ -20,7 +20,7 @@
 # software solely pursuant to the terms of the relevant commercial agreement.
 
 import logging
-from datetime import datetime, date
+from datetime import date, datetime
 
 from sqlalchemy import types as sqltypes
 from sqlalchemy.engine import default, reflection
@@ -28,11 +28,11 @@ from sqlalchemy.sql import functions
 from sqlalchemy.util import asbool, to_list
 
 from .compiler import (
-    CrateTypeCompiler,
     CrateDDLCompiler,
     CrateIdentifierPreparer,
+    CrateTypeCompiler,
 )
-from .sa_version import SA_VERSION, SA_1_4, SA_2_0
+from .sa_version import SA_1_4, SA_2_0, SA_VERSION
 from .type import FloatVector, ObjectArray, ObjectType
 
 TYPES_MAP = {
@@ -54,9 +54,12 @@ TYPES_MAP = {
     "text": sqltypes.String,
     "float_vector": FloatVector,
 }
+
+# Needed for SQLAlchemy >= 1.1.
+# TODO: Dissolve.
 try:
-    # SQLAlchemy >= 1.1
     from sqlalchemy.types import ARRAY
+
     TYPES_MAP["integer_array"] = ARRAY(sqltypes.Integer)
     TYPES_MAP["boolean_array"] = ARRAY(sqltypes.Boolean)
     TYPES_MAP["short_array"] = ARRAY(sqltypes.SmallInteger)
@@ -71,7 +74,7 @@ try:
     TYPES_MAP["real_array"] = ARRAY(sqltypes.Float)
     TYPES_MAP["string_array"] = ARRAY(sqltypes.String)
     TYPES_MAP["text_array"] = ARRAY(sqltypes.String)
-except Exception:
+except Exception:  # noqa: S110
     pass
 
 
@@ -82,14 +85,16 @@ class Date(sqltypes.Date):
     def bind_processor(self, dialect):
         def process(value):
             if value is not None:
-                assert isinstance(value, date)
-                return value.strftime('%Y-%m-%d')
+                assert isinstance(value, date)  # noqa: S101
+                return value.strftime("%Y-%m-%d")
+            return None
+
         return process
 
     def result_processor(self, dialect, coltype):
         def process(value):
             if not value:
-                return
+                return None
             try:
                 return datetime.utcfromtimestamp(value / 1e3).date()
             except TypeError:
@@ -103,27 +108,29 @@ class Date(sqltypes.Date):
             # the date will be returned in the format it was inserted.
             log.warning(
                 "Received timestamp isn't a long value."
-                "Trying to parse as date string and then as datetime string")
+                "Trying to parse as date string and then as datetime string"
+            )
             try:
-                return datetime.strptime(value, '%Y-%m-%d').date()
+                return datetime.strptime(value, "%Y-%m-%d").date()
             except ValueError:
-                return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%fZ').date()
+                return datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%fZ").date()
+
         return process
 
 
 class DateTime(sqltypes.DateTime):
-
     def bind_processor(self, dialect):
         def process(value):
             if isinstance(value, (datetime, date)):
-                return value.strftime('%Y-%m-%dT%H:%M:%S.%f%z')
+                return value.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
             return value
+
         return process
 
     def result_processor(self, dialect, coltype):
         def process(value):
             if not value:
-                return
+                return None
             try:
                 return datetime.utcfromtimestamp(value / 1e3)
             except TypeError:
@@ -137,11 +144,13 @@ class DateTime(sqltypes.DateTime):
             # the date will be returned in the format it was inserted.
             log.warning(
                 "Received timestamp isn't a long value."
-                "Trying to parse as datetime string and then as date string")
+                "Trying to parse as datetime string and then as date string"
+            )
             try:
-                return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%fZ')
+                return datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%fZ")
             except ValueError:
-                return datetime.strptime(value, '%Y-%m-%d')
+                return datetime.strptime(value, "%Y-%m-%d")
+
         return process
 
 
@@ -154,19 +163,22 @@ colspecs = {
 
 if SA_VERSION >= SA_2_0:
     from .compat.core20 import CrateCompilerSA20
+
     statement_compiler = CrateCompilerSA20
 elif SA_VERSION >= SA_1_4:
     from .compat.core14 import CrateCompilerSA14
+
     statement_compiler = CrateCompilerSA14
 else:
     from .compat.core10 import CrateCompilerSA10
+
     statement_compiler = CrateCompilerSA10
 
 
 class CrateDialect(default.DefaultDialect):
-    name = 'crate'
-    driver = 'crate-python'
-    default_paramstyle = 'qmark'
+    name = "crate"
+    driver = "crate-python"
+    default_paramstyle = "qmark"
     statement_compiler = statement_compiler
     ddl_compiler = CrateDDLCompiler
     type_compiler = CrateTypeCompiler
@@ -192,15 +204,13 @@ class CrateDialect(default.DefaultDialect):
 
         # Currently, our SQL parser doesn't support unquoted column names that
         # start with _. Adding it here causes sqlalchemy to quote such columns.
-        self.identifier_preparer.illegal_initial_characters.add('_')
+        self.identifier_preparer.illegal_initial_characters.add("_")
 
     def initialize(self, connection):
         # get lowest server version
-        self.server_version_info = \
-            self._get_server_version_info(connection)
+        self.server_version_info = self._get_server_version_info(connection)
         # get default schema name
-        self.default_schema_name = \
-            self._get_default_schema_name(connection)
+        self.default_schema_name = self._get_default_schema_name(connection)
 
     def do_rollback(self, connection):
         # if any exception is raised by the dbapi, sqlalchemy by default
@@ -212,9 +222,9 @@ class CrateDialect(default.DefaultDialect):
     def connect(self, host=None, port=None, *args, **kwargs):
         server = None
         if host:
-            server = '{0}:{1}'.format(host, port or '4200')
-        if 'servers' in kwargs:
-            server = kwargs.pop('servers')
+            server = "{0}:{1}".format(host, port or "4200")
+        if "servers" in kwargs:
+            server = kwargs.pop("servers")
         servers = to_list(server)
         if servers:
             use_ssl = asbool(kwargs.pop("ssl", False))
@@ -224,7 +234,7 @@ class CrateDialect(default.DefaultDialect):
         return self.dbapi.connect(**kwargs)
 
     def _get_default_schema_name(self, connection):
-        return 'doc'
+        return "doc"
 
     def _get_effective_schema_name(self, connection):
         schema_name_raw = connection.engine.url.query.get("schema")
@@ -241,6 +251,7 @@ class CrateDialect(default.DefaultDialect):
     @classmethod
     def import_dbapi(cls):
         from crate import client
+
         return client
 
     @classmethod
@@ -256,9 +267,7 @@ class CrateDialect(default.DefaultDialect):
     @reflection.cache
     def get_schema_names(self, connection, **kw):
         cursor = connection.exec_driver_sql(
-            "select schema_name "
-            "from information_schema.schemata "
-            "order by schema_name asc"
+            "select schema_name " "from information_schema.schemata " "order by schema_name asc"
         )
         return [row[0] for row in cursor.fetchall()]
 
@@ -271,7 +280,7 @@ class CrateDialect(default.DefaultDialect):
             "WHERE {0} = ? "
             "AND table_type = 'BASE TABLE' "
             "ORDER BY table_name ASC, {0} ASC".format(self.schema_column),
-            (schema or self.default_schema_name, )
+            (schema or self.default_schema_name,),
         )
         return [row[0] for row in cursor.fetchall()]
 
@@ -280,22 +289,25 @@ class CrateDialect(default.DefaultDialect):
         cursor = connection.exec_driver_sql(
             "SELECT table_name FROM information_schema.views "
             "ORDER BY table_name ASC, {0} ASC".format(self.schema_column),
-            (schema or self.default_schema_name, )
+            (schema or self.default_schema_name,),
         )
         return [row[0] for row in cursor.fetchall()]
 
     @reflection.cache
     def get_columns(self, connection, table_name, schema=None, **kw):
-        query = "SELECT column_name, data_type " \
-                "FROM information_schema.columns " \
-                "WHERE table_name = ? AND {0} = ? " \
-                "AND column_name !~ ?" \
-                .format(self.schema_column)
+        query = (
+            "SELECT column_name, data_type "
+            "FROM information_schema.columns "
+            "WHERE table_name = ? AND {0} = ? "
+            "AND column_name !~ ?".format(self.schema_column)
+        )
         cursor = connection.exec_driver_sql(
             query,
-            (table_name,
-             schema or self.default_schema_name,
-             r"(.*)\[\'(.*)\'\]")  # regex to filter subscript
+            (
+                table_name,
+                schema or self.default_schema_name,
+                r"(.*)\[\'(.*)\'\]",
+            ),  # regex to filter subscript
         )
         return [self._create_column_info(row) for row in cursor.fetchall()]
 
@@ -330,17 +342,14 @@ class CrateDialect(default.DefaultDialect):
                 rows = result.fetchone()
                 return set(rows[0] if rows else [])
 
-        pk_result = engine.exec_driver_sql(
-            query,
-            (table_name, schema or self.default_schema_name)
-        )
+        pk_result = engine.exec_driver_sql(query, (table_name, schema or self.default_schema_name))
         pks = result_fun(pk_result)
-        return {'constrained_columns': list(sorted(pks)),
-                'name': 'PRIMARY KEY'}
+        return {"constrained_columns": sorted(pks), "name": "PRIMARY KEY"}
 
     @reflection.cache
-    def get_foreign_keys(self, connection, table_name, schema=None,
-                         postgresql_ignore_search_path=False, **kw):
+    def get_foreign_keys(
+        self, connection, table_name, schema=None, postgresql_ignore_search_path=False, **kw
+    ):
         # Crate doesn't support Foreign Keys, so this stays empty
         return []
 
@@ -354,12 +363,12 @@ class CrateDialect(default.DefaultDialect):
 
     def _create_column_info(self, row):
         return {
-            'name': row[0],
-            'type': self._resolve_type(row[1]),
+            "name": row[0],
+            "type": self._resolve_type(row[1]),
             # In Crate every column is nullable except PK
             # Primary Key Constraints are not nullable anyway, no matter what
             # we return here, so it's fine to return always `True`
-            'nullable': True
+            "nullable": True,
         }
 
     def _resolve_type(self, type_):

sqlalchemy_cratedb/predicate.py

@@ -19,8 +19,8 @@
 # with Crate these terms will supersede the license and you may use the
 # software solely pursuant to the terms of the relevant commercial agreement.
 
-from sqlalchemy.sql.expression import ColumnElement, literal
 from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.sql.expression import ColumnElement, literal
 
 
 class Match(ColumnElement):
@@ -35,9 +35,8 @@ class Match(ColumnElement):
 
     def compile_column(self, compiler):
         if isinstance(self.column, dict):
-            column = ', '.join(
-                sorted(["{0} {1}".format(compiler.process(k), v)
-                       for k, v in self.column.items()])
+            column = ", ".join(
+                sorted(["{0} {1}".format(compiler.process(k), v) for k, v in self.column.items()])
             )
             return "({0})".format(column)
         else:
@@ -51,21 +50,22 @@ class Match(ColumnElement):
             using = "using {0}".format(self.match_type)
             with_clause = self.with_clause()
             if with_clause:
-                using = ' '.join([using, with_clause])
+                using = " ".join([using, with_clause])
             return using
         if self.options:
-            raise ValueError("missing match_type. " +
-                             "It's not allowed to specify options " +
-                             "without match_type")
+            raise ValueError(
+                "missing match_type. "
+                + "It's not allowed to specify options "
+                + "without match_type"
+            )
+        return None
 
     def with_clause(self):
         if self.options:
-            options = ', '.join(
-                sorted(["{0}={1}".format(k, v)
-                       for k, v in self.options.items()])
-            )
+            options = ", ".join(sorted(["{0}={1}".format(k, v) for k, v in self.options.items()]))
 
             return "with ({0})".format(options)
+        return None
 
 
 def match(column, term, match_type=None, options=None):
@@ -89,11 +89,8 @@ def match(column, term, match_type=None, options=None):
 
 @compiles(Match)
 def compile_match(match, compiler, **kwargs):
-    func = "match(%s, %s)" % (
-        match.compile_column(compiler),
-        match.compile_term(compiler)
-    )
+    func = "match(%s, %s)" % (match.compile_column(compiler), match.compile_term(compiler))
     using = match.compile_using(compiler)
     if using:
-        func = ' '.join([func, using])
+        func = " ".join([func, using])
     return func