mtsql 1.11.18__py3-none-any.whl → 1.11.20__py3-none-any.whl

mt/sql/redshift/commands.py

@@ -2,6 +2,7 @@ import enum
 import numbers
 import re
 import warnings
+
 try:
     from collections.abc import Iterable
 except ImportError:
@@ -23,49 +24,55 @@ from sqlalchemy.sql import expression as sa_expression
 # The pattern of IAM role ARNs can be found here:
 #   http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-iam
 
-ACCESS_KEY_ID_RE = re.compile('[A-Z0-9]{20}')
-SECRET_ACCESS_KEY_RE = re.compile('[A-Za-z0-9/+=]{40}')
-TOKEN_RE = re.compile('[A-Za-z0-9/+=]+')
-AWS_PARTITIONS = frozenset({'aws', 'aws-cn', 'aws-us-gov'})
-AWS_ACCOUNT_ID_RE = re.compile('[0-9]{12}')
-IAM_ROLE_NAME_RE = re.compile('[A-Za-z0-9+=,.@\-_]{1,64}')  # noqa
-IAM_ROLE_ARN_RE = re.compile('arn:(aws|aws-cn|aws-us-gov):iam::'
-                             '[0-9]{12}:role/[A-Za-z0-9+=,.@\-_]{1,64}')  # noqa
-
-
-def _process_aws_credentials(access_key_id=None, secret_access_key=None,
-                             session_token=None, aws_partition='aws',
-                             aws_account_id=None, iam_role_name=None,
-                             iam_role_arns=None):
+ACCESS_KEY_ID_RE = re.compile("[A-Z0-9]{20}")
+SECRET_ACCESS_KEY_RE = re.compile("[A-Za-z0-9/+=]{40}")
+TOKEN_RE = re.compile("[A-Za-z0-9/+=]+")
+AWS_PARTITIONS = frozenset({"aws", "aws-cn", "aws-us-gov"})
+AWS_ACCOUNT_ID_RE = re.compile("[0-9]{12}")
+IAM_ROLE_NAME_RE = re.compile("[A-Za-z0-9+=,.@\-_]{1,64}")  # noqa
+IAM_ROLE_ARN_RE = re.compile(
+    "arn:(aws|aws-cn|aws-us-gov):iam::" "[0-9]{12}:role/[A-Za-z0-9+=,.@\-_]{1,64}"
+)  # noqa
+
+
+def _process_aws_credentials(
+    access_key_id=None,
+    secret_access_key=None,
+    session_token=None,
+    aws_partition="aws",
+    aws_account_id=None,
+    iam_role_name=None,
+    iam_role_arns=None,
+):
     uses_iam_role = aws_account_id is not None and iam_role_name is not None
     uses_iam_roles = iam_role_arns is not None
     uses_key = access_key_id is not None and secret_access_key is not None
 
     if uses_iam_role + uses_iam_roles + uses_key > 1:
         raise TypeError(
-            'Either access key based credentials or role based credentials '
-            'should be specified, but not both'
+            "Either access key based credentials or role based credentials "
+            "should be specified, but not both"
         )
 
     credentials = None
 
     if aws_account_id is not None and iam_role_name is not None:
         if aws_partition not in AWS_PARTITIONS:
-            raise ValueError('invalid AWS partition')
+            raise ValueError("invalid AWS partition")
         if not AWS_ACCOUNT_ID_RE.match(aws_account_id):
             raise ValueError(
-                'invalid AWS account ID; does not match {pattern}'.format(
+                "invalid AWS account ID; does not match {pattern}".format(
                     pattern=AWS_ACCOUNT_ID_RE.pattern,
                 )
             )
         elif not IAM_ROLE_NAME_RE.match(iam_role_name):
             raise ValueError(
-                'invalid IAM role name; does not match {pattern}'.format(
+                "invalid IAM role name; does not match {pattern}".format(
                     pattern=IAM_ROLE_NAME_RE.pattern,
                 )
             )
 
-        credentials = 'aws_iam_role=arn:{0}:iam::{1}:role/{2}'.format(
+        credentials = "aws_iam_role=arn:{0}:iam::{1}:role/{2}".format(
             aws_partition,
             aws_account_id,
             iam_role_name,
@@ -75,32 +82,32 @@ def _process_aws_credentials(access_key_id=None, secret_access_key=None,
         if isinstance(iam_role_arns, str):
             iam_role_arns = [iam_role_arns]
         if not isinstance(iam_role_arns, list):
-            raise ValueError('iam_role_arns must be a list')
+            raise ValueError("iam_role_arns must be a list")
         for arn in iam_role_arns:
             if not IAM_ROLE_ARN_RE.match(arn):
                 raise ValueError(
-                    'invalid AWS account ID; does not match {pattern}'.format(
+                    "invalid AWS account ID; does not match {pattern}".format(
                         pattern=IAM_ROLE_ARN_RE.pattern,
                     )
                 )
 
-        credentials = 'aws_iam_role=' + ','.join(iam_role_arns)
+        credentials = "aws_iam_role=" + ",".join(iam_role_arns)
 
     if access_key_id is not None and secret_access_key is not None:
         if not ACCESS_KEY_ID_RE.match(access_key_id):
             raise ValueError(
-                'invalid access_key_id; does not match {pattern}'.format(
+                "invalid access_key_id; does not match {pattern}".format(
                     pattern=ACCESS_KEY_ID_RE.pattern,
                 )
             )
         if not SECRET_ACCESS_KEY_RE.match(secret_access_key):
             raise ValueError(
-                'invalid secret_access_key; does not match {pattern}'.format(
+                "invalid secret_access_key; does not match {pattern}".format(
                     pattern=SECRET_ACCESS_KEY_RE.pattern,
                 )
             )
 
-        credentials = 'aws_access_key_id={0};aws_secret_access_key={1}'.format(
+        credentials = "aws_access_key_id={0};aws_secret_access_key={1}".format(
             access_key_id,
             secret_access_key,
         )
@@ -108,27 +115,26 @@ def _process_aws_credentials(access_key_id=None, secret_access_key=None,
         if session_token is not None:
             if not TOKEN_RE.match(session_token):
                 raise ValueError(
-                    'invalid session_token; does not match {pattern}'.format(
+                    "invalid session_token; does not match {pattern}".format(
                         pattern=TOKEN_RE.pattern,
                     )
                 )
-            credentials += ';token={0}'.format(session_token)
+            credentials += ";token={0}".format(session_token)
 
     if credentials is None:
         raise TypeError(
-            'Either access key based credentials or role based credentials '
-            'should be specified'
+            "Either access key based credentials or role based credentials "
+            "should be specified"
         )
 
     return credentials
 
 
 def _process_fixed_width(spec):
-    return ','.join(('{0}:{1:d}'.format(col, width) for col, width in spec))
+    return ",".join(("{0}:{1:d}".format(col, width) for col, width in spec))
 
 
-class _ExecutableClause(sa_expression.Executable,
-                        sa_expression.ClauseElement):
+class _ExecutableClause(sa_expression.Executable, sa_expression.ClauseElement):
     pass
 
 
@@ -159,10 +165,10 @@ class AlterTableAppendCommand(_ExecutableClause):
         fill those columns with the default column value or NULL. Mutually
         exclusive with `ignore_extra`.
     """
+
     def __init__(self, source, target, ignore_extra=False, fill_target=False):
         if ignore_extra and fill_target:
-            raise ValueError(
-                '"ignore_extra" cannot be used with "fill_target".')
+            raise ValueError('"ignore_extra" cannot be used with "fill_target".')
 
         self.source = source
         self.target = target
@@ -176,18 +182,17 @@ def visit_alter_table_append_command(element, compiler, **kw):
     Returns the actual SQL query for the AlterTableAppendCommand class.
     """
     if element.ignore_extra:
-        fill_option = 'IGNOREEXTRA'
+        fill_option = "IGNOREEXTRA"
     elif element.fill_target:
-        fill_option = 'FILLTARGET'
+        fill_option = "FILLTARGET"
     else:
-        fill_option = ''
+        fill_option = ""
 
-    query_text = \
-        'ALTER TABLE {target} APPEND FROM {source} {fill_option}'.format(
-            target=compiler.preparer.format_table(element.target),
-            source=compiler.preparer.format_table(element.source),
-            fill_option=fill_option,
-        )
+    query_text = "ALTER TABLE {target} APPEND FROM {source} {fill_option}".format(
+        target=compiler.preparer.format_table(element.target),
+        source=compiler.preparer.format_table(element.source),
+        fill_option=fill_option,
+    )
     return compiler.process(sa.text(query_text), **kw)
 
 
@@ -269,24 +274,38 @@ class UnloadFromSelect(_ExecutableClause):
         Indicates the type of file to unload to.
     """
 
-    def __init__(self, select, unload_location, access_key_id=None,
-                 secret_access_key=None, session_token=None,
-                 aws_partition='aws', aws_account_id=None, iam_role_name=None,
-                 manifest=False, delimiter=None, fixed_width=None,
-                 encrypted=False, gzip=False, add_quotes=False, null=None,
-                 escape=False, allow_overwrite=False, parallel=True,
-                 header=False, region=None, max_file_size=None,
-                 format=None, iam_role_arns=None):
+    def __init__(
+        self,
+        select,
+        unload_location,
+        access_key_id=None,
+        secret_access_key=None,
+        session_token=None,
+        aws_partition="aws",
+        aws_account_id=None,
+        iam_role_name=None,
+        manifest=False,
+        delimiter=None,
+        fixed_width=None,
+        encrypted=False,
+        gzip=False,
+        add_quotes=False,
+        null=None,
+        escape=False,
+        allow_overwrite=False,
+        parallel=True,
+        header=False,
+        region=None,
+        max_file_size=None,
+        format=None,
+        iam_role_arns=None,
+    ):
 
         if delimiter is not None and len(delimiter) != 1:
-            raise ValueError(
-                '"delimiter" parameter must be a single character'
-            )
+            raise ValueError('"delimiter" parameter must be a single character')
 
         if header and fixed_width is not None:
-            raise ValueError(
-                "'header' cannot be used with 'fixed_width'"
-            )
+            raise ValueError("'header' cannot be used with 'fixed_width'")
 
         credentials = _process_aws_credentials(
             access_key_id=access_key_id,
@@ -342,87 +361,96 @@ def visit_unload_from_select(element, compiler, **kw):
     el = element
 
     if el.format is None:
-        format_ = ''
+        format_ = ""
     elif el.format == Format.csv:
-        format_ = 'FORMAT AS {}'.format(el.format.value)
+        format_ = "FORMAT AS {}".format(el.format.value)
         if el.delimiter is not None or el.fixed_width is not None:
-            raise ValueError(
-                'CSV format cannot be used with delimiter or fixed_width')
+            raise ValueError("CSV format cannot be used with delimiter or fixed_width")
     elif el.format == Format.parquet:
-        format_ = 'FORMAT AS {}'.format(el.format.value)
-        if any((
-            el.delimiter, el.fixed_width, el.add_quotes, el.escape, el.null,
-            el.header, el.gzip
-        )):
+        format_ = "FORMAT AS {}".format(el.format.value)
+        if any(
+            (
+                el.delimiter,
+                el.fixed_width,
+                el.add_quotes,
+                el.escape,
+                el.null,
+                el.header,
+                el.gzip,
+            )
+        ):
             raise ValueError(
                 "Parquet format can't be used with `delimiter`, `fixed_width`,"
-                ' `add_quotes`, `escape`, `null`, `header`, or `gzip`.'
+                " `add_quotes`, `escape`, `null`, `header`, or `gzip`."
             )
     else:
-        raise ValueError(
-            'Only CSV and Parquet formats are currently supported.'
-        )
+        raise ValueError("Only CSV and Parquet formats are currently supported.")
 
     qs = template.format(
-        manifest='MANIFEST' if el.manifest else '',
-        header='HEADER' if el.header else '',
+        manifest="MANIFEST" if el.manifest else "",
+        header="HEADER" if el.header else "",
         format=format_,
-        delimiter=(
-            'DELIMITER AS :delimiter' if el.delimiter is not None else ''
-        ),
-        encrypted='ENCRYPTED' if el.encrypted else '',
-        fixed_width='FIXEDWIDTH AS :fixed_width' if el.fixed_width else '',
-        gzip='GZIP' if el.gzip else '',
-        add_quotes='ADDQUOTES' if el.add_quotes else '',
-        escape='ESCAPE' if el.escape else '',
-        null='NULL AS :null_as' if el.null is not None else '',
-        allow_overwrite='ALLOWOVERWRITE' if el.allow_overwrite else '',
-        parallel='PARALLEL OFF' if not el.parallel else '',
-        region='REGION :region' if el.region is not None else '',
+        delimiter=("DELIMITER AS :delimiter" if el.delimiter is not None else ""),
+        encrypted="ENCRYPTED" if el.encrypted else "",
+        fixed_width="FIXEDWIDTH AS :fixed_width" if el.fixed_width else "",
+        gzip="GZIP" if el.gzip else "",
+        add_quotes="ADDQUOTES" if el.add_quotes else "",
+        escape="ESCAPE" if el.escape else "",
+        null="NULL AS :null_as" if el.null is not None else "",
+        allow_overwrite="ALLOWOVERWRITE" if el.allow_overwrite else "",
+        parallel="PARALLEL OFF" if not el.parallel else "",
+        region="REGION :region" if el.region is not None else "",
         max_file_size=(
-            'MAXFILESIZE :max_file_size MB'
-            if el.max_file_size is not None else ''
+            "MAXFILESIZE :max_file_size MB" if el.max_file_size is not None else ""
         ),
     )
 
     query = sa.text(qs)
 
     if el.delimiter is not None:
-        query = query.bindparams(sa.bindparam(
-            'delimiter', value=element.delimiter, type_=sa.String,
-        ))
+        query = query.bindparams(
+            sa.bindparam(
+                "delimiter",
+                value=element.delimiter,
+                type_=sa.String,
+            )
+        )
 
     if el.fixed_width:
-        query = query.bindparams(sa.bindparam(
-            'fixed_width',
-            value=_process_fixed_width(el.fixed_width),
-            type_=sa.String,
-        ))
+        query = query.bindparams(
+            sa.bindparam(
+                "fixed_width",
+                value=_process_fixed_width(el.fixed_width),
+                type_=sa.String,
+            )
+        )
 
     if el.null is not None:
-        query = query.bindparams(sa.bindparam(
-            'null_as', value=el.null, type_=sa.String
-        ))
+        query = query.bindparams(
+            sa.bindparam("null_as", value=el.null, type_=sa.String)
+        )
 
     if el.region is not None:
-        query = query.bindparams(sa.bindparam(
-            'region', value=el.region, type_=sa.String
-        ))
+        query = query.bindparams(
+            sa.bindparam("region", value=el.region, type_=sa.String)
+        )
 
     if el.max_file_size is not None:
         max_file_size_mib = float(el.max_file_size) / 1024 / 1024
-        query = query.bindparams(sa.bindparam(
-            'max_file_size', value=max_file_size_mib, type_=sa.Float
-        ))
+        query = query.bindparams(
+            sa.bindparam("max_file_size", value=max_file_size_mib, type_=sa.Float)
+        )
 
     return compiler.process(
         query.bindparams(
-            sa.bindparam('credentials', value=el.credentials, type_=sa.String),
+            sa.bindparam("credentials", value=el.credentials, type_=sa.String),
             sa.bindparam(
-                'unload_location', value=el.unload_location, type_=sa.String,
+                "unload_location",
+                value=el.unload_location,
+                type_=sa.String,
             ),
             sa.bindparam(
-                'select',
+                "select",
                 value=compiler.process(
                     el.select,
                     literal_binds=True,
@@ -435,25 +463,25 @@ def visit_unload_from_select(element, compiler, **kw):
 
 
 class Format(enum.Enum):
-    csv = 'CSV'
-    json = 'JSON'
-    avro = 'AVRO'
-    orc = 'ORC'
-    parquet = 'PARQUET'
-    fixed_width = 'FIXEDWIDTH'
+    csv = "CSV"
+    json = "JSON"
+    avro = "AVRO"
+    orc = "ORC"
+    parquet = "PARQUET"
+    fixed_width = "FIXEDWIDTH"
 
 
 class Compression(enum.Enum):
-    gzip = 'GZIP'
-    lzop = 'LZOP'
-    bzip2 = 'BZIP2'
+    gzip = "GZIP"
+    lzop = "LZOP"
+    bzip2 = "BZIP2"
 
 
 class Encoding(enum.Enum):
-    utf8 = 'UTF8'
-    utf16 = 'UTF16'
-    utf16le = 'UTF16LE'
-    utf16be = 'UTF16BE'
+    utf8 = "UTF8"
+    utf16 = "UTF16"
+    utf16le = "UTF16LE"
+    utf16be = "UTF16BE"
 
 
 def _check_enum(Enum, val):
@@ -462,7 +490,7 @@ def _check_enum(Enum, val):
 
     cleaned = Enum(val)
     if cleaned is not val:
-        tpl = '{val!r} should be, {cleaned!r}, an instance of {Enum!r}'
+        tpl = "{val!r} should be, {cleaned!r}, an instance of {Enum!r}"
         msg = tpl.format(val=val, cleaned=cleaned, Enum=Enum)
         warnings.warn(msg, DeprecationWarning)
 
@@ -610,21 +638,48 @@ class CopyCommand(_ExecutableClause):
         cluster isn't in the same region as the S3 bucket.
     """
 
-    def __init__(self, to, data_location, access_key_id=None,
-                 secret_access_key=None, session_token=None,
-                 aws_partition='aws', aws_account_id=None, iam_role_name=None,
-                 format=None, quote=None,
-                 path_file='auto', delimiter=None, fixed_width=None,
-                 compression=None, accept_any_date=False,
-                 accept_inv_chars=None, blanks_as_null=False, date_format=None,
-                 empty_as_null=False, encoding=None, escape=False,
-                 explicit_ids=False, fill_record=False,
-                 ignore_blank_lines=False, ignore_header=None,
-                 dangerous_null_delimiter=None, remove_quotes=False,
-                 roundec=False, time_format=None, trim_blanks=False,
-                 truncate_columns=False, comp_rows=None, comp_update=None,
-                 max_error=None, no_load=False, stat_update=None,
-                 manifest=False, region=None, iam_role_arns=None):
+    def __init__(
+        self,
+        to,
+        data_location,
+        access_key_id=None,
+        secret_access_key=None,
+        session_token=None,
+        aws_partition="aws",
+        aws_account_id=None,
+        iam_role_name=None,
+        format=None,
+        quote=None,
+        path_file="auto",
+        delimiter=None,
+        fixed_width=None,
+        compression=None,
+        accept_any_date=False,
+        accept_inv_chars=None,
+        blanks_as_null=False,
+        date_format=None,
+        empty_as_null=False,
+        encoding=None,
+        escape=False,
+        explicit_ids=False,
+        fill_record=False,
+        ignore_blank_lines=False,
+        ignore_header=None,
+        dangerous_null_delimiter=None,
+        remove_quotes=False,
+        roundec=False,
+        time_format=None,
+        trim_blanks=False,
+        truncate_columns=False,
+        comp_rows=None,
+        comp_update=None,
+        max_error=None,
+        no_load=False,
+        stat_update=None,
+        manifest=False,
+        region=None,
+        iam_role_arns=None,
+    ):
 
         credentials = _process_aws_credentials(
             access_key_id=access_key_id,
@@ -637,14 +692,11 @@ class CopyCommand(_ExecutableClause):
         )
 
         if delimiter is not None and len(delimiter) != 1:
-            raise ValueError('"delimiter" parameter must be a single '
-                             'character')
+            raise ValueError('"delimiter" parameter must be a single ' "character")
 
         if ignore_header is not None:
             if not isinstance(ignore_header, numbers.Integral):
-                raise TypeError(
-                    '"ignore_header" parameter should be an integer'
-                )
+                raise TypeError('"ignore_header" parameter should be an integer')
 
         table = None
         columns = []
@@ -652,10 +704,8 @@ class CopyCommand(_ExecutableClause):
             for column in to:
                 if table is not None and table != column.table:
                     raise ValueError(
-                        'All columns must come from the same table: '
-                        '%s comes from %s not %s' % (
-                            column, column.table, table
-                        ),
+                        "All columns must come from the same table: "
+                        "%s comes from %s not %s" % (column, column.table, table),
                     )
                 columns.append(column)
                 table = column.table
@@ -710,189 +760,211 @@ def visit_copy_command(element, compiler, **kw):
     parameters = []
     bindparams = [
         sa.bindparam(
-            'data_location',
+            "data_location",
             value=element.data_location,
             type_=sa.String,
         ),
         sa.bindparam(
-            'credentials',
+            "credentials",
             value=element.credentials,
             type_=sa.String,
         ),
     ]
 
     if element.format == Format.csv:
-        format_ = 'FORMAT AS CSV'
+        format_ = "FORMAT AS CSV"
         if element.quote is not None:
-            format_ += ' QUOTE AS :quote_character'
-            bindparams.append(sa.bindparam(
-                'quote_character',
-                value=element.quote,
-                type_=sa.String,
-            ))
+            format_ += " QUOTE AS :quote_character"
+            bindparams.append(
+                sa.bindparam(
+                    "quote_character",
+                    value=element.quote,
+                    type_=sa.String,
+                )
+            )
     elif element.format == Format.json:
-        format_ = 'FORMAT AS JSON AS :json_option'
-        bindparams.append(sa.bindparam(
-            'json_option',
-            value=element.path_file,
-            type_=sa.String,
-        ))
+        format_ = "FORMAT AS JSON AS :json_option"
+        bindparams.append(
+            sa.bindparam(
+                "json_option",
+                value=element.path_file,
+                type_=sa.String,
+            )
+        )
     elif element.format == Format.avro:
-        format_ = 'FORMAT AS AVRO AS :avro_option'
-        bindparams.append(sa.bindparam(
-            'avro_option',
-            value=element.path_file,
-            type_=sa.String,
-        ))
+        format_ = "FORMAT AS AVRO AS :avro_option"
+        bindparams.append(
+            sa.bindparam(
+                "avro_option",
+                value=element.path_file,
+                type_=sa.String,
+            )
+        )
     elif element.format == Format.orc:
-        format_ = 'FORMAT AS ORC'
+        format_ = "FORMAT AS ORC"
     elif element.format == Format.parquet:
-        format_ = 'FORMAT AS PARQUET'
+        format_ = "FORMAT AS PARQUET"
     elif element.format == Format.fixed_width and element.fixed_width is None:
         raise sa_exc.CompileError(
-            "'fixed_width' argument required for format 'FIXEDWIDTH'.")
+            "'fixed_width' argument required for format 'FIXEDWIDTH'."
+        )
     else:
-        format_ = ''
+        format_ = ""
 
     if element.delimiter is not None:
-        parameters.append('DELIMITER AS :delimiter_char')
-        bindparams.append(sa.bindparam(
-            'delimiter_char',
-            value=element.delimiter,
-            type_=sa.String,
-        ))
+        parameters.append("DELIMITER AS :delimiter_char")
+        bindparams.append(
+            sa.bindparam(
+                "delimiter_char",
+                value=element.delimiter,
+                type_=sa.String,
+            )
+        )
 
     if element.fixed_width is not None:
-        parameters.append('FIXEDWIDTH AS :fixedwidth_spec')
-        bindparams.append(sa.bindparam(
-            'fixedwidth_spec',
-            value=_process_fixed_width(element.fixed_width),
-            type_=sa.String,
-        ))
+        parameters.append("FIXEDWIDTH AS :fixedwidth_spec")
+        bindparams.append(
+            sa.bindparam(
+                "fixedwidth_spec",
+                value=_process_fixed_width(element.fixed_width),
+                type_=sa.String,
+            )
+        )
 
     if element.compression is not None:
         parameters.append(Compression(element.compression).value)
 
     if element.manifest:
-        parameters.append('MANIFEST')
+        parameters.append("MANIFEST")
 
     if element.accept_any_date:
-        parameters.append('ACCEPTANYDATE')
+        parameters.append("ACCEPTANYDATE")
 
     if element.accept_inv_chars is not None:
-        parameters.append('ACCEPTINVCHARS AS :replacement_char')
-        bindparams.append(sa.bindparam(
-            'replacement_char',
-            value=element.accept_inv_chars,
-            type_=sa.String
-        ))
+        parameters.append("ACCEPTINVCHARS AS :replacement_char")
+        bindparams.append(
+            sa.bindparam(
+                "replacement_char", value=element.accept_inv_chars, type_=sa.String
+            )
+        )
 
     if element.blanks_as_null:
-        parameters.append('BLANKSASNULL')
+        parameters.append("BLANKSASNULL")
 
     if element.date_format is not None:
-        parameters.append('DATEFORMAT AS :dateformat_string')
-        bindparams.append(sa.bindparam(
-            'dateformat_string',
-            value=element.date_format,
-            type_=sa.String,
-        ))
+        parameters.append("DATEFORMAT AS :dateformat_string")
+        bindparams.append(
+            sa.bindparam(
+                "dateformat_string",
+                value=element.date_format,
+                type_=sa.String,
+            )
+        )
 
     if element.empty_as_null:
-        parameters.append('EMPTYASNULL')
+        parameters.append("EMPTYASNULL")
 
     if element.encoding is not None:
-        parameters.append('ENCODING AS ' + Encoding(element.encoding).value)
+        parameters.append("ENCODING AS " + Encoding(element.encoding).value)
 
     if element.escape:
-        parameters.append('ESCAPE')
+        parameters.append("ESCAPE")
 
     if element.explicit_ids:
-        parameters.append('EXPLICIT_IDS')
+        parameters.append("EXPLICIT_IDS")
 
     if element.fill_record:
-        parameters.append('FILLRECORD')
+        parameters.append("FILLRECORD")
 
     if element.ignore_blank_lines:
-        parameters.append('IGNOREBLANKLINES')
+        parameters.append("IGNOREBLANKLINES")
 
     if element.ignore_header is not None:
-        parameters.append('IGNOREHEADER AS :number_rows')
-        bindparams.append(sa.bindparam(
-            'number_rows',
-            value=element.ignore_header,
-            type_=sa.Integer,
-        ))
+        parameters.append("IGNOREHEADER AS :number_rows")
+        bindparams.append(
+            sa.bindparam(
+                "number_rows",
+                value=element.ignore_header,
+                type_=sa.Integer,
+            )
+        )
 
     if element.dangerous_null_delimiter is not None:
         parameters.append("NULL AS '%s'" % element.dangerous_null_delimiter)
 
     if element.remove_quotes:
-        parameters.append('REMOVEQUOTES')
+        parameters.append("REMOVEQUOTES")
 
     if element.roundec:
-        parameters.append('ROUNDEC')
+        parameters.append("ROUNDEC")
 
     if element.time_format is not None:
-        parameters.append('TIMEFORMAT AS :timeformat_string')
-        bindparams.append(sa.bindparam(
-            'timeformat_string',
-            value=element.time_format,
-            type_=sa.String,
-        ))
+        parameters.append("TIMEFORMAT AS :timeformat_string")
+        bindparams.append(
+            sa.bindparam(
+                "timeformat_string",
+                value=element.time_format,
+                type_=sa.String,
+            )
+        )
 
     if element.trim_blanks:
-        parameters.append('TRIMBLANKS')
+        parameters.append("TRIMBLANKS")
 
     if element.truncate_columns:
-        parameters.append('TRUNCATECOLUMNS')
+        parameters.append("TRUNCATECOLUMNS")
 
     if element.comp_rows:
-        parameters.append('COMPROWS :numrows')
-        bindparams.append(sa.bindparam(
-            'numrows',
-            value=element.comp_rows,
-            type_=sa.Integer,
-        ))
+        parameters.append("COMPROWS :numrows")
+        bindparams.append(
+            sa.bindparam(
+                "numrows",
+                value=element.comp_rows,
+                type_=sa.Integer,
+            )
+        )
 
     if element.comp_update:
-        parameters.append('COMPUPDATE ON')
+        parameters.append("COMPUPDATE ON")
     elif element.comp_update is not None:
-        parameters.append('COMPUPDATE OFF')
+        parameters.append("COMPUPDATE OFF")
 
     if element.max_error is not None:
-        parameters.append('MAXERROR AS :error_count')
-        bindparams.append(sa.bindparam(
-            'error_count',
-            value=element.max_error,
-            type_=sa.Integer,
-        ))
+        parameters.append("MAXERROR AS :error_count")
+        bindparams.append(
+            sa.bindparam(
+                "error_count",
+                value=element.max_error,
+                type_=sa.Integer,
+            )
+        )
 
     if element.no_load:
-        parameters.append('NOLOAD')
+        parameters.append("NOLOAD")
 
     if element.stat_update:
-        parameters.append('STATUPDATE ON')
+        parameters.append("STATUPDATE ON")
     elif element.stat_update is not None:
-        parameters.append('STATUPDATE OFF')
+        parameters.append("STATUPDATE OFF")
 
     if element.region is not None:
-        parameters.append('REGION :region')
-        bindparams.append(sa.bindparam(
-            'region',
-            value=element.region,
-            type_=sa.String
-        ))
+        parameters.append("REGION :region")
+        bindparams.append(sa.bindparam("region", value=element.region, type_=sa.String))
 
-    columns = ' (%s)' % ', '.join(
-        compiler.preparer.format_column(column) for column in element.columns
-    ) if element.columns else ''
+    columns = (
+        " (%s)"
+        % ", ".join(
+            compiler.preparer.format_column(column) for column in element.columns
+        )
+        if element.columns
+        else ""
+    )
 
     qs = qs.format(
         table=compiler.preparer.format_table(element.table),
         columns=columns,
         format=format_,
-        parameters='\n'.join(parameters)
+        parameters="\n".join(parameters),
     )
 
     return compiler.process(sa.text(qs).bindparams(*bindparams), **kw)
@@ -941,10 +1013,20 @@ class CreateLibraryCommand(_ExecutableClause):
         The AWS region where the library's S3 bucket is located, if the
         Redshift cluster isn't in the same region as the S3 bucket.
     """
-    def __init__(self, library_name, location, access_key_id=None,
-                 secret_access_key=None, session_token=None,
-                 aws_account_id=None, iam_role_name=None, replace=False,
-                 region=None, iam_role_arns=None):
+
+    def __init__(
+        self,
+        library_name,
+        location,
+        access_key_id=None,
+        secret_access_key=None,
+        session_token=None,
+        aws_account_id=None,
+        iam_role_name=None,
+        replace=False,
+        region=None,
+        iam_role_arns=None,
+    ):
         self.library_name = library_name
         self.location = location
         self.credentials = _process_aws_credentials(
@@ -973,28 +1055,32 @@ def visit_create_library_command(element, compiler, **kw):
     """
     bindparams = [
         sa.bindparam(
-            'location',
+            "location",
             value=element.location,
             type_=sa.String,
         ),
         sa.bindparam(
-            'credentials',
+            "credentials",
             value=element.credentials,
             type_=sa.String,
         ),
     ]
 
     if element.region is not None:
-        bindparams.append(sa.bindparam(
-            'region',
-            value=element.region,
-            type_=sa.String,
-        ))
+        bindparams.append(
+            sa.bindparam(
+                "region",
+                value=element.region,
+                type_=sa.String,
+            )
+        )
 
     quoted_lib_name = compiler.preparer.quote_identifier(element.library_name)
-    query = query.format(name=quoted_lib_name,
-                         or_replace='OR REPLACE' if element.replace else '',
-                         region='REGION :region' if element.region else '')
+    query = query.format(
+        name=quoted_lib_name,
+        or_replace="OR REPLACE" if element.replace else "",
+        region="REGION :region" if element.region else "",
+    )
     return compiler.process(sa.text(query).bindparams(*bindparams), **kw)
 
 
@@ -1009,7 +1095,7 @@ class RefreshMaterializedView(_ExecutableClause):
 
     >>> import sqlalchemy as sa
     >>> from sqlalchemy_redshift.dialect import RefreshMaterializedView
-    >>> engine = sa.create_engine('redshift+psycopg2://example')
+    >>> engine = sa.create_engine('mtsql_redshift://example')
     >>> refresh = RefreshMaterializedView('materialized_view_of_users')
     >>> print(refresh.compile(engine))
     <BLANKLINE>
@@ -1019,6 +1105,7 @@ class RefreshMaterializedView(_ExecutableClause):
 
     This can be included in any execute() statement.
     """
+
     def __init__(self, name):
         """
         Builds the Executable/ClauseElement that represents the refresh command