NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
PyPI, #920 most downloaded on PyPI
Python DB API 2.0 (PEP 249) client for Amazon Athena
Latest stable
4.3.0
Last release 6 days ago
16 Nov 2026
Ships fairly regularly
a new release about every 4 weeks
Nearly every release is documented
notes for 60 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
10 years old
192 releases · first in 2017
Drag across the ruler to compare, or tap a release to open it.
connection= of S3FileSystem and AioS3FileSystem emits a DeprecationWarning and will be removed in the next major version ( #1378 ). Use pyathena.files…
These concern code that uses S3FileSystem or AioS3FileSystem directly or through fsspec. For the cursors, see the first item of Behavior changes.
S3FileSystem.ls() and AioS3FileSystem._ls() raise FileNotFoundError for a key path that is neither an object nor a directory, instead of returning [] (#1347). listdir() and tree() of such a path raise too, and S3FileSystem.walk() yields nothing for it with the default on_error="omit" (it yielded (path, [], [])). find(), glob(), du(), info(), and exists() are unchanged, and an existing empty bucket still lists as [].S3FileSystem raise ValueError before any transfer for pairs whose result would depend on the order of the transfers (#1344): two pairs of get, put, copy, or pipe with a dict that have the same destination after normalization, get destinations that are the same local file or file-like object, and a copy destination that is the source of another pair. For example, copy("b/d/", "b/d/sub/", recursive=True) raises when b/d/sub/ already holds objects. AioS3FileSystem does not check these pairs yet (#1398).S3FileSystem and AioS3FileSystem raise TypeError when connection= (or the new client=) is given together with an argument that builds a client, which they used to ignore (#1378). These are key/username, secret/password, token, profile/profile_name, anon (also anon=False), use_ssl, endpoint_url, connect_timeout, read_timeout, client_kwargs, config_kwargs, and the boto3 session arguments, such as region_name. A value of None and settings from fsspec's configuration, such as FSSPEC_S3_ENDPOINT_URL, do not count.connection= of S3FileSystem and AioS3FileSystem emits a DeprecationWarning and will be removed in the next major version (#1378). Use pyathena.filesystem.s3_filesystem(connection) or client=connection.s3_client, retry_config=connection.retry_config. In storage_options, replace {"connection": conn} with {"client": conn.s3_client, "retry_config": conn.retry_config}. S3FSCursor still passes connection= to a custom filesystem_class, including subclasses of S3FileSystem, until then (#1386).S3FileSystem.rm(max_workers=) and AioS3FileSystem._rm(max_workers=) are deprecated aliases of the new batch_size= and emit a DeprecationWarning; giving both raises TypeError (#1344, #1395).loop argument of S3AioExecutor is ignored and emits a DeprecationWarning (#1357).PandasCursor, PolarsCursor, and their async and asyncio variants read result files through PyAthena's S3 filesystem with at most 10 parallel requests by default, instead of cpu_count() * 5 (#1359). The default s3_max_workers is None, which takes the max_pool_connections of the connection's S3 client (10 unless configured). To read with more parallel requests, raise the client's connection pool, which raises this default too:
from botocore.config import Config
from pyathena import connect
conn = connect(..., s3_config=Config(max_pool_connections=50))An s3_max_workers above the client's max_pool_connections opens connections beyond the pool, which urllib3 closes after use with a "Connection pool is full" warning.
max_workers of S3FileSystem and AioS3FileSystem is the max_pool_connections of the S3 client (10 unless configured) instead of cpu_count() * 5, and the files and operations of a filesystem share one request pool of max_workers threads (#1359). With the defaults, a single large read or write runs 10 requests at once. A client that the filesystem builds gets max_pool_connections = max_workers when max_workers is given and config_kwargs does not set it; a client given with client= keeps its own.mv() deletes its sources only after every copy succeeded.S3File and AioS3StreamedFile raise a failure, an interrupt, or a cancellation once their running range reads have ended, and an interrupt of rm() or clear_multipart_uploads() cancels the requests that have not started (#1367).AioS3FileSystem, including one cancelled by asyncio.wait_for(), raises once the call that it runs in a thread has ended, instead of at once; a second cancellation raises at once (#1395). A cancelled _put_file(), _pipe_file(), or _get_file() ends its transfer instead of committing in the background, and in a transaction it is discarded instead of committed. The batch coroutines _cat(), _cat_ranges(), _pipe(), _put(), _get(), and _copy() cancel their per-object tasks and wait for them. A cancelled AioS3StreamedFile.close() waits for its requests before it raises (#1359).AioS3FileSystem.open() and S3AioExecutor run their calls in a thread pool instead of through fsspec's event loop (#1357). S3ThreadPoolExecutor and S3AioThreadPool are aliases of the new S3ThreadPool, and S3AioExecutor is its subclass, so they are no longer distinct for isinstance().RuntimeError when used, and closing them only marks them closed, instead of hanging or committing or aborting the parent's upload (#1353, #1357, #1359). Create a new filesystem in the child.S3File that is finalized without having been closed, during a cyclic garbage collection or in a thread of the filesystem's pools, is closed and committed in a separate thread after the collection, and the interpreter waits for these closes at exit (#1396). In other threads, its finalizer still closes it before the drop of its last reference returns.ls() and find() of a path with a version ID return only that version, named bucket/key?versionId=<id>, and report a missing version as info() does (#1361). They used to list the keys under key/.dir//, is listed as the directory bucket/dir/ instead of bucket/dir (#1361).S3FileSystem.glob() and the expansion of get(), copy(), cat(), and rm() list only the keys that start with the part of the pattern before the first wildcard; the matches are unchanged (#1395).FileNotFoundError instead of PermissionError from info(), cat_file(), open(), and S3Core.head_object() / get_object(), and exists() returns False for it (#1345).ValueError from every filesystem call, with botocore's ParamValidationError as the __cause__ (#1389). Before, only mkdir() converted it, with its own message.rm_file() rejects Bucket, Key, and VersionId, and touch() rejects Body, with TypeError (#1377).open() sends the caller's IfMatch as given instead of replacing it with the ETag that it looked up (#1369). A reopened or unpickled file whose object was replaced fails with 412 (OSError(EINVAL)) instead of reading the new object, and a pickled file contains its request parameters, including an SSE-C key.get_file() ignores cache_type and cache_options (#1399). AioS3FileSystem._get() pairs its paths as S3FileSystem.get() does, and each of its downloads gets max(1, max_workers // n) range reads for n files.to_sql()role_arn or serial_number, the profile, key, and botocore_session arguments sign only the STS requests; the connection's Athena, Glue, and S3 clients use a new botocore session (#1366). The upload workers of to_sql() get the connection's current credentials, which are not refreshed during the uploads.to_sql() runs its SQL on an internal Cursor whatever the connection's cursor class is, so the options of that class (unload, chunksize, arraysize, converter, and custom arguments) no longer apply to it (#1392). Its table lookup disables query result reuse. With an AioConnection, it runs synchronously instead of failing.S3FileSystem and AioS3FileSystem take a boto3 S3 client with client= and a retry policy with retry_config=, and pyathena.filesystem.s3_filesystem(connection) creates a filesystem from a connection's client and policy (#1378). The filesystem borrows the client and does not close it. Pickling a filesystem built with client= or connection=, or a file it opened for reading, raises TypeError with guidance.cat, cat_ranges, get, put, pipe with a dict, copy, and mv of S3FileSystem transfer objects concurrently, at most batch_size at once (a new argument; max_workers by default) (#1344). rm(batch_size=) is the number of DeleteObjects requests sent at once.get() and get_file() download each object in parallel ranges of the block size, up to max_workers at once, and hold at most one wave of ranges in memory (#1399).SlowDown, ServiceUnavailable, InternalError, and RequestTimeout when the exceptions of its retry policy are the default codes (#1400), and so does to_sql() with the connection's default policy, for its uploads and, with if_exists="replace", the listing and deletion of the existing objects (#1413). A persistent S3 error therefore takes longer to raise. The "Retries" section of the filesystem guide describes how these retries combine with botocore's, whose default retry mode changed in botocore 1.44.0 (#1412).S3FileSystem and AioS3FileSystem accepts an os.PathLike path, such as pathlib.PurePosixPath("bucket/key") (#1394). Many methods raised TypeError or AttributeError for one, and get() and put() wrote to the wrong place. The path parameters are annotated str | os.PathLike[str], so a subclass that overrides one with path: str gets a mypy error.RequestPayer, ExpectedBucketOwner, and SSECustomer* set in s3_additional_kwargs are sent with every request whose operation accepts them, including listings, and for the source of a copy (#1377). For example, cat_file() of an SSE-C object works with the key set on the filesystem. With an SSECustomerKey there, every object that the filesystem reads or copies must be encrypted with that key.S3FileSystem has close() and supports with, which release the idle threads of its request pool; the filesystem stays usable (#1359).S3Executor.map() and map_async() with S3MapResult (#1367), S3ClientError.code_of() (#1367, #1389), S3Core.copy_source_params() (#1362), and S3Core.resolve_retry_config() (#1413).role_arn or serial_number keep working past duration_seconds: they refresh the STS credentials before they expire, and with serial_number they prompt for an MFA code again (#1366).to_sql(if_exists="replace") raises OperationalError, listing the objects that remain, when S3 cannot delete some of the existing objects under the location (#1415). It used to write the new data next to them, so the new table also read the old objects. The table has already been dropped then, and to_sql() deletes objects only when the table exists, so delete the remaining objects before calling it again.RequestPayer, expected owner, and SSE-C parameters with the lookups of the source, and so does setxattr() (#1362). rm_file() sends the parameters that DeleteObject accepts, such as RequestPayer, and mkdir() those of CreateBucket (#1377).S3File (metadata(), getxattr(), url(), and setxattr()) send the file's request parameters; an append pins the existing object that it reads or copies; "ab", "xb", and mode="create" treat a key that is only a prefix of other keys as no object; and commit() in read mode does nothing (#1369).chmod(recursive=True) also updates the object at the key when objects lie below it, and updates only the given version of a version path (#1370).find() with maxdepth, walk(), and tree() descend into directories whose keys contain ?versionId= or an empty segment, and writes below such directories invalidate their cached listings (#1405).get_file(..., compression=...) decompresses the object instead of raising AttributeError after truncating the destination (#1399).Body given to S3Core.call() is sent from its starting position on each retry, instead of from its end, which could write an empty object (#1400).S3Core.part_ranges(0, block_size) returns [], and S3Core.call() resolves the operation of a functools.partial (#1345).AioS3FileSystem: a recursive _put() no longer sends HeadBucket or CreateBucket for each local directory; _expand_path() passes refresh= and prefix= to the listing; _rm(batch_size=) is used instead of ignored, and max_workers is no longer sent to DeleteObjects; _cp_file() no longer sends recursive, maxdepth, and on_error to CopyObject (#1395).PolarsCursor reads a whole CSV result with PyAthena's S3 filesystem instead of the filesystem registered for s3 in fsspec, unless storage_options is given (#1365).Note truncated.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Faster conversion of timestamp , date , time , timestamp with time zone , and time with time zone values in the rows of Cursor , DictCursor , S3FSCurs
timestamp, date, time, timestamp with time zone, and time with time zone values in the rows of Cursor, DictCursor, S3FSCursor, and their async variants, of the timestamp with time zone, time, and time with time zone values in the rows of ArrowCursor and PolarsCursor, and of time columns in PandasCursor's CSV reads (#1308, #1312).PolarsCursor read of a CSV result no longer holds a second copy of the result file, so its peak memory returns to that of 4.1.0 (#1307, #1313).PandasCursor no longer fails when parse_dates leaves out a time column, or when index_col names a time column (#1308, #1312).fromisoformat(), which accepts more ISO 8601 forms than the previous strptime() formats, such as a T separator, basic forms like 20240102, and a trailing offset. Athena does not write these forms, so only text from other sources is affected: it now converts instead of raising ValueError (#1312).encoding other than UTF-8 given to PolarsCursor.execute() is not decoded for an unchunked CSV read and makes the read fail with OperationalError, as in 4.1.0. Athena writes CSV results in UTF-8 (#1313).Full Changelog: v4.2.0...v4.2.1
A closed cursor raises ProgrammingError("Cursor is closed.") from execute() , executemany() , the fetch methods, iteration, cancel() , the metadata me
ProgrammingError("Cursor is closed.") from execute(), executemany(), the fetch methods, iteration, cancel(), the metadata methods, and its other methods (#1274). Before, fetches returned None or [] and execute() ran a new query. Cursors have a new is_closed property.ProgrammingError from its fetch methods, iteration, as_pandas(), as_arrow(), as_polars(), and iter_chunks(), instead of returning None, [], or an empty DataFrame or table (#1274).next() on an asyncio cursor or result set raises TypeError instead of returning an un-awaited coroutine (#1274).fetchone(), fetchmany(), and fetchall() calls raise ProgrammingError (#1238). Before, the pandas and Polars result sets returned no more rows, and the other result sets continued after the skipped rows. Invalid arguments, such as a non-integer fetchmany() size, do not count as a failed fetch.threadsafety = 2 declares (#1238). This includes cancel() from a timer thread and close() during a fetch. To stop a query from another thread, use its query ID.AioPandasCursor, AioArrowCursor, AioPolarsCursor, or AioS3FSCursor drops the result set from the cursor, so later fetches raise ProgrammingError("No result set.") (#1238). A cancelled as_*() call of these cursors does the same (#1286).AioPandasCursor.as_pandas(), AioPolarsCursor.as_polars() / as_arrow(), and AioArrowCursor.as_arrow() / as_polars() are coroutines: use await cursor.as_pandas() (#1286). AioPandasCursor.as_pandas() always returns a DataFrame. To read chunks one at a time, use the new async iter_chunks() of AioPandasCursor and AioPolarsCursor.close() of AsyncCursor or one of its variants (dict, pandas, Arrow, Polars, S3FS), the futures of execute(), description(), and poll() that still wait for their query raise ProgrammingError (#1279, #1300). The query is not cancelled. A result set built after the close is closed before its future resolves. The futures of cancel() and query_execution() still run. A result set whose future resolved before the close stays open and belongs to the caller.AsyncCursor.description(query_id) reads only the result set metadata, or the Parquet schema of an UNLOAD result, and no longer reads the result rows (#1300). It uses the new metadata reader classes, such as AthenaResultSetMetadataReader. A custom result set class that overrides the description property no longer changes what description(query_id) returns; make that change in its metadata reader class instead.AsyncPandasCursor and AioPandasCursor.
timestamp is always datetime64[us], and digits beyond microseconds are truncated. It was [ns] for 7 or more fractional digits, [s] when all values were NULL or with engine="pyarrow" and no fraction, [ns] with engine="pyarrow" and a fraction, and str when a column also held values outside the nanosecond range.timestamp with time zone is datetime64[us, UTC]. It had the data's zone, or was object for several zones or an all-NULL column.date from UNLOAD results is datetime64[us], as from CSV results. It was object (date).datetime, date, and aware datetime in UTC, and None for NULL. They returned pd.Timestamp and NaT.parse_dates, dtype, or converters is given to execute(), PyAthena leaves the temporal columns to pandas, and the fetch methods return pandas' values for them.engine="pyarrow" is now also used for results with timestamp with time zone columns.timestamp with time zone value raises DataError when its zone name is unknown, or when its zone repeats or skips its local time (daylight saving time) (#1224). Before, it returned a naive datetime or the earlier instant. Convert such values to UTC in SQL (AT TIME ZONE 'UTC') or read to_unixtime(). tzdata>=2024.2 is required.S3File.multipart_upload is read-only, and S3File.multipart_upload_parts is removed (#1232). S3File.completed_parts returns the uploaded or copied parts in part-number order. commit() raises S3MultipartStateError after discard() or after a failed write or commit. Before, it uploaded the buffered data after a discard and did nothing after a failure.get_std_out() / get_std_error(), raises OperationalError instead of the botocore exception (#1278). Callers that catch botocore errors there must catch OperationalError.fetchmany() and fetchall() now take rows through _take_rows(). A subclass whose fetchone() does not use the row buffer must override _take_rows() as well (#1195). Several private result set helpers moved to the metadata reader classes or were removed (#1300).datetime64[us], timestamp[us], and Datetime("us"), as for CSV results. Values outside 1677-09-21 to 2262-04-11 are now correct; before, they were wrapped or saturated.
coerce_int96_timestamp_unit given to execute() still replaces the unit. coerce_int96_timestamp_unit=None is the same as not giving it (#1291).schema given to execute() is used as given.execute() read them correctly (#1282).date from CSV results as date32 instead of timestamp[ms], as from UNLOAD results (#1236). as_polars() gives pl.Date instead of pl.Datetime("ms").time, time with time zone, and timestamp with time zone values of CSV results as null instead of '' (#1236). The fetch methods still return None.DataError naming the column (Column 'name': ...) (#1273, #1277). PandasCursor whole reads raise it instead of an OperationalError that wrapped it. A DataError from a function given in converters is still wrapped in OperationalError.ignore_errors=True truncates a CSV timestamp with more than nine fractional digits instead of returning null (#1234). Text that is not a timestamp is still null.new_columns is given together with schema_overrides, it must name every column.map, and its values are dicts.ArrowCursor.as_polars() returns map columns as pl.Map.row instead of array.PolarsCursor, AioPolarsCursor, and AsyncPolarsCursor, the HeadObject size check runs when the result set is created, and its error is raised there instead of at the first fetch (#1190).iter_chunks() or as_pandas(), raise ProgrammingError at their next read once their result set is closed, for example by another query on the cursor (#1286). Before, they ended without an error.[]. For a chunked pandas read whose files hold no rows, engine="c" now raises ProgrammingError.to_sql() with the default flavor="spark" creates tables whose column names have spaces, tabs, newlines, and ,;{}()= replaced with _, matching the names in the Parquet files (#1299). Such columns used to read as NULL. Tables created before keep the old names, and appending does not change them; recreate them, for example with if_exists="replace".AioCursor pages, and object construction (#1223). A request already sent still runs to its end. The cleanup requests (StopQueryExecution, StopCalculationExecution, TerminateSession) keep their retries.AioS3FileSystem coroutine stops the retries of its S3 requests (#1231). Cancelling a chunked UNLOAD read of AioPandasCursor or AioPolarsCursor stops the retries of the requests that open its Parquet files (#1297). Closing a chunked UNLOAD result no longer waits for the retries of a Parquet file being opened ahead (#1297).AioS3FileSystem runs its blocking calls, including multipart copies, in a pool of up to max_workers threads of the filesystem (#1184). Each of its files uses a pool of up to max_workers threads. The event loop's default executor no longer limits them, so a process can use more threads than before. A max_workers that is not positive raises ValueError when the filesystem is created. After S3AioExecutor.shutdown(), submit() raises RuntimeError.S3File multipart writes keep at most max_workers parts in flight, counting the part copies of an append, and a write waits until a part finishes (#1165, #1232). A part that failed is raised by the next write(), flush(), or close(), which closes the file without committing it (#1176, #1183, #1232). Before, it was raised only by close() or commit(). Inside an fsspec transaction, the error is raised by the write. If the caller catches it, the transaction fails when it commits. Committing again after a successful commit sends no request.chmod stops after the first failed update, and the keys it has not updated keep their ACL (#1231).S3Executor, the frames below S3Core.call() or the executor no longer hold local variables, for example in pdb.pm() (#1192).executemany() closes only the result set after a failure, not the cursor (#1274).The benchmark of this release ran on commit 9e99caa8 (#1288), whose package code is identical to this release: the release commit baee716c differs from it only in one test file (#1311). Its history entries are benchmarks/history/2026-10-19-9e99caa8.md and benchmarks/history/2026-10-19-9e99caa8-filesystem.md (#1310). Highlights:
pandas.read_sql_query() through the result-file drivers is faster, because the row output of PandasCursor and PolarsCursor is faster (#1167, #1177). For 10 million flat rows, awsathena+pandas with unload=true took 50.7 seconds instead of 162.6, and awsathena+polars with unload=true 48.7 seconds instead of 92.0.AioS3FileSystem writes and copies as fast as S3FileSystem with 40 workers (#1184): a 6 GiB multipart copy ran at 1,889–1,925 MiB/s instead of 521–540.chunksize=100000.Note truncated.
The asyncio SQLAlchemy adapter classes in pyathena.aio.sqlalchemy.base are renamed, with no aliases for the old names: AsyncAdapt_pyathena_cursor → At
pyathena.aio.sqlalchemy.base are renamed, with no aliases for the old names: AsyncAdapt_pyathena_cursor → AthenaAioAdaptedCursor, AsyncAdapt_pyathena_connection → AthenaAioAdaptedConnection, AsyncAdapt_pyathena_dbapi → AthenaAioAdaptedDBAPI (#1151). Code that imports the old names must use the new ones. Engines created with the awsathena+aio* URLs are unaffected.json columns with pandas' default low_memory=True and converts the json columns after parsing (#1141). pandas now applies these options to the JSON text instead of the converted value:
parse_dates naming a json column no longer parses a JSON string such as "2020-01-01", which keeps its quotes; cast in SQL instead.engine="python" and NA options such as keep_default_na=True, a JSON string that matches an NA token, such as "NA", stays a string; SQL NULL is still None.The benchmark of this release is in benchmarks/history/2026-10-13-437276e1.md and benchmarks/history/2026-10-13-437276e1-filesystem.md (#1157). Highlights:
Full Changelog: v4.0.0...v4.1.0
Read Breaking changes before upgrading. The usage guide has migration sections for the keyword-only arguments, the worker settings, and the environmen…
v4.0.0 changes the project's copyright notices. Please read the Copyright and license notices section first and review NOTICE. The license itself is still the MIT License.
v4.0.0 is a major release from master, which was branched from the 3.x line at v3.36.0. It drops Python 3.10, raises the minimum versions of the core and optional dependencies, makes connection and cursor settings keyword-only, and rejects arguments that used to be ignored silently. It also contains a large number of fixes and behavior changes across the cursors, the SQLAlchemy dialect, Spark, and the S3 filesystem.
Read Breaking changes before upgrading. The usage guide has migration sections for the keyword-only arguments, the worker settings, and the environment fallbacks ("... in PyAthena 4.0" in docs/usage.md), and the Spark and S3FS guides have their own 4.0 sections. Users who need Python 3.10, pandas 2, an older pyarrow or Polars, or SQLAlchemy 1.x can stay on the 3.x maintenance line (latest v3.39.0).
Several fixes in this release were already backported to 3.x in v3.37.0, v3.38.0, and v3.39.0. They are listed under Already in 3.x releases at the end and marked in "What's Changed"; users upgrading from v3.39.0 already have them.
Thanks to @mvanhorn for the STRUCT DDL fix (#870), to @aminghadersohi for the bare awsathena:// scheme fix (#839) and for reporting #854, #855, and #857, and to @innicoder for reporting the memory issue #417, which #1001 addresses.
LICENSE changes from "laughingman7743" to "The PyAthena authors" (Copyright 2017 The PyAthena authors). The license terms are unchanged (MIT) (#809, #790).MIT with LICENSE and NOTICE as license files, so both files are included in the sdist and wheel (#809).Copyright <year> The PyAthena authors with SPDX-License-Identifier: MIT. Existing files written solely by the maintainer received it, new original files must carry it, and a check enforces the headers across the repository (#805, #808).NOTICE file acknowledges PyHive, which informed PyAthena's early development, and lists the parts that still follow it, with PyHive's Apache License 2.0 notice. It also records the other third-party material (the GitHub Actions OIDC CloudFormation template and strtobool) and explains which files do not carry the header, such as files with contributions from other contributors, whose authorship is recorded in the Git history (#802). The per-file classification is recorded in #790.NOTICE together with LICENSE.boto3>=1.43.31 and botocore>=1.43.31 (was 1.41.2). botocore 1.43.31 is the first release with the S3 annotation operations used by multipart copies.fsspec>=2026.9.0 (no lower bound before).tenacity>=8.0.1 (was 4.1.0). Older releases break retry_api_call(): releases before 6.1.0 fail on Python 3.11+, and 8.0.0 raises TypeError from after_log on the first retry. (Also in v3.39.0.)python-dateutil is no longer a dependency; tzdata is required.sqlalchemy: sqlalchemy>=2.0.0 (was 1.0.0). Environments pinned to SQLAlchemy 1.4 cannot install pyathena[sqlalchemy] 4.0.0.pandas: pandas>=3.0.0.arrow: pyarrow>=22.0.0.polars: polars>=1.39.0 (was 1.0.0). This applies even to users who never set chunksize: Polars 1.34–1.36 silently truncate chunked reads on errors, and Polars before 1.39 fill a local file cache that is not released.Development Status :: 5 - Production/Stable (#904, #865).TypeError. execute() keeps operation and parameters positional and requires keywords after them. connection.cursor(CursorClass) still works (#1101, #1092).cursor_kwargs, raise TypeError. execute() of the default, dict, Arrow, S3FS, and Spark cursors raises TypeError for unknown keywords before changing cursor state or starting a query. The pandas and Polars cursors still pass unused execute() keywords to the reader, which rejects unknown ones when it reads the results. connection.cursor(OtherCursor) raises if cursor_kwargs contain options that OtherCursor does not accept. A cursor subclass that passes its own settings from cursor_kwargs on to the base constructor must consume them first (#1102, #1093).PandasCursor, PolarsCursor, AioPandasCursor, and AioPolarsCursor is renamed from max_workers to s3_max_workers, in the constructor and in execute(). In AsyncPandasCursor and AsyncPolarsCursor, max_workers sizes only the cursor's thread pool and s3_max_workers sets the S3 read workers; pass both to AsyncPolarsCursor to keep its former values. The old name raises TypeError (in execute(), when the result set is created after the query has run) (#1103, #1094).arraysize passed at cursor creation now takes effect and is validated: Cursor, DictCursor, AioCursor, AioDictCursor, AsyncCursor, and AsyncDictCursor raise ProgrammingError for values above 1000, and every SQL cursor raises it for zero or negative values. Before, the value was ignored by Cursor, DictCursor, AioCursor, and AioDictCursor (since v2.0.0), so a small value now means more GetQueryResults calls. The Arrow, pandas, Polars, and S3FS cursors still accept values above 1000 (#901, #897).connect(endpoint_url=...) no longer applies to S3. Setups that serve Athena and S3 from one endpoint (for example LocalStack) need AWS_ENDPOINT_URL_S3 or AWS_ENDPOINT_URL. This affects the result sets, S3FileSystem(connection=...), Polars storage_options, the Spark cursors, and to_sql() (#1058, #1011).work_group follows the same environment fallback rule as s3_staging_dir: only an omitted argument or None reads AWS_ATHENA_WORK_GROUP; an explicit empty string skips the fallback and means no work group (#1108, #1096).DefaultCSVReader (S3FS cursor) is renamed to EmptyStringAsNullCSVReader, without an alias (#1107, #1097).pyathena.formatter._escape_presto; use _escape_trino.BaseCursor._execute() / AioBaseCursor._execute(); pass options=ExecuteOptions(...).pyathena.util.strtobool() returns bool instead of int; call int(strtobool(value)) where an integer is required.pyathena.sqlalchemy.types.get_double_type is removed; use sqlalchemy.types.DOUBLE (#860).AthenaDialect declares SQLAlchemy 2.0's type_compiler_cls instead of the legacy type_compiler, so code that reads AthenaDialect.type_compiler on the class no longer finds the compiler class (#895, #894).TypeEngine.compile(dialect) renders AthenaStruct as STRUCT<name:type> instead of ROW(name type), and Integer (including subclasses and TypeDecorators over it) as INT in all DDL.Integer().with_variant(OtherType(), "awsathena") renders the variant in CREATE TABLE.JSON column, an AthenaStruct without fields, and NullType in DDL raise CompileError instead of emitting DDL that Athena rejects. CAST(... AS JSON) is unchanged. CLOB/NCLOB render STRING instead of BINARY.SparkCursor, AsyncSparkCursor, and AioSparkCursor raise NotSupportedError for any parameters value other than None, and their execute() no longer takes work_group (TypeError, even for None). Before, both were silently ignored (#1108, #1096).session_id no longer terminates that session. Pass terminate_session_on_close=True to keep the previous behavior (#844, #793, #796).S3FileSystem.PATTERN_PATH and S3FileSystem.parse_path() / AioS3FileSystem.parse_path() are removed. Use S3Path.parse(path) and its bucket, key, and version_id attributes (#1100, #1052).S3FileSystem.OBJECT_ACLS, BUCKET_ACLS, and the MULTIPART_UPLOAD_* limits are removed; use S3Core.OBJECT_ACLS / S3Core.BUCKET_ACLS (for example fs.core.OBJECT_ACLS) (#1090).max_worker keyword of open() and pipe_file() is removed; pass max_workers (#948, #925).open() for writing or appending (wb, ab, xb) raises ValueError for a path with ?versionId= (#958, #936).find(maxdepth=n) lists n levels instead of n + 1, and maxdepth=0 raises ValueError. rm(), glob(), du(), expand_path(), copy(), and get() pass maxdepth through find(), so rm(path, recursive=True, maxdepth=1) no longer deletes the objects one level below the path. Callers relying on the old numbering need maxdepth + 1 (#956, #933).S3FileSystem.request_kwargs is a read-only property that returns a copy; pass requester_pays=True to the constructor instead of changing it (#1060).S3File calls submit_to() on its executor. An executor passed to S3File that does not subclass S3Executor must provide it (#1113).S3Core (S3FileSystem.core, AioS3FileSystem.core) with typed listing entries, pages, and delete/multipart/copy/tagging/ACL/presign requests; S3Path; S3MultipartWriter; S3Executor.submit_to(); connect(s3_config=...) and Connection.s3_client; TERMINAL_STATES on the query and calculation execution models (#1060, #1052, #1085, #1113, #1058, #881).pyathena/ has a Google-style docstring, checked with ruff (#919).kill_on_interrupt=True, an interrupt during execute() of a SQL cursor now propagates as KeyboardInterrupt / asyncio.CancelledError after the query is stopped, instead of surfacing as OperationalError or being lost when the query succeeded. asyncio.wait_for() now raises TimeoutError. An interrupt while a query is being started waits for StartQueryExecution and stops the query it started (#853, #840).cursor() argument now overrides the same key in the connection's cursor_kwargs; before, cursor_kwargs won silently (#872, #859).dict_type passed to one dict cursor no longer changes the row type of other dict cursors, and dict_type=None uses the default (#930, #923).Connection.close() closes the network connections of its clients. SQLAlchemy URLs with use_ssl=false now disable TLS, as connect(use_ssl=False) does (#1058, #1011).date columns are datetime64, array/map/row are Athena text, a result without rows has its columns, and result_set_type_hints no longer applies to these cursors on managed storage (#1061, #1028, #1042).ArrowCursor reads timestamp columns as timestamp[us] instead of timestamp[ms]; the Arrow and (unchunked) Polars cursors read timestamps with more than 6 fractional digits, truncated to the column's unit (#1061).time with time zone values are aware datetime.time objects in Cursor, S3FSCursor, ArrowCursor, PolarsCursor, and PandasCursor (strings or naive times before).timestamp with time zone values are aware datetime objects in the Arrow and Polars cursors and in every PandasCursor column.zoneinfo.ZoneInfo instead of dateutil.tz.tzfile; instants and offsets are unchanged. With PandasCursor, the dtype changes from, for example, datetime64[us, tzfile('/usr/share/zoneinfo/America/New_York')] to datetime64[us, America/New_York]. A zone that the time zone database cannot provide logs a warning.TIME(0) and TIME(p) with p > 6 no longer raise ValueError.chunksize, repeated as_pandas() / as_polars() / as_arrow() calls return the whole result, as_pandas() / as_polars() return the same object until close() or the next execute(), and fetches after them return the rows (#1005, #935).None for NULL (object dtype), and integer columns on managed storage are Int64 (#1044, #1027). CSV reads with the C engine and PyAthena's JSON converter default to low_memory=False to avoid DtypeWarning (#1080, #1078).engine="pyarrow", CSV results are read with pyarrow.csv: multi-line values that cross a read block are read correctly, and string columns are no longer changed ("007" used to become "7.0") (#1057, #1048, #1065, #1062).execute() can override the cursor's read options, and AsyncPandasCursor(block_size=..., cache_type=..., auto_optimize_chunksize=...) now takes effect (#1022, #938).to_sql() uses the connection's config/s3_config and, with connect(session=...), that session's credentials (#1068, #1067).PandasCursor and ArrowCursor return None for SQL NULL json values; with managed storage, json columns in as_arrow() / as_polars() are string columns, and S3FSCursor uses the configured converter (#1010, #934).PolarsCursor with unload=True and chunksize describes and returns the Parquet columns (broken since v3.24.0) (#1012, #1007).ArrowCursor maps Arrow decimal32/decimal64 columns to decimal (decimal256 also in v3.38.0) (#900, #888).get_table_metadata(), list_table_metadata(), and list_databases() answer a throttled request from the AWS Glue Data Catalog in AwsDataCatalog and S3 Tables catalogs. The fallback needs glue:GetTable, glue:GetTables, and glue:GetDatabases; without them, the Athena request is retried as before after one failed Glue call and a warning. Turn it off with connect(glue_metadata_fallback=False) or glue_metadata_fallback=false in a SQLAlchemy URL. retry_api_call() / async_retry_api_call() accept a keyword-only stop_on predicate (#803, #786, #890, #887).executemany() reports the total affected row count instead of -1 (#768, #754).executemany inserts are batched into multi-row INSERT statements (insertmanyvalues, 100 rows per statement by default; rowcount stays the total). A failed statement fails one page of rows and earlier pages stay inserted, and before_cursor_execute listeners see multi-row statements. Very wide rows may exceed Athena's query length limit; lower insertmanyvalues_page_size or set use_insertmanyvalues=False. Both options are also accepted in the URL query and by engine_from_config (#838, #835, #843).Date and DateTime render typed DATE '...' / TIMESTAMP '...' literals, and literal_execute no longer raises NotImplementedError.cast() to DateTime renders TIMESTAMP(6). Hive CTAS and UNLOAD (including cursors with unload=True) reject timestamp(6) output columns; use cast(col, AthenaTimestamp(precision=3)) or CAST(... AS TIMESTAMP(3)) there.AthenaTimestamp(precision=p) (0–6) casts to TIMESTAMP(p) and truncates bound values.cast() to a TypeDecorator (or a with_variant() type) casts to its implementation type (#836, #829).map<...> columns reflect as AthenaMap and struct<...> / row(...) columns as AthenaStruct with their fields; unparsable types reflect as NullType with a warning (#995, #886, #857; reflection also in v3.38.0).information_schema, and listed metadata is reused within one Inspector (#777, #780). The dialect's own queries always use an API cursor, whatever cursor_class is configured, and a federated catalog's missing table is resolved from information_schema (#798, #781, #783, #785).has_table() results are cached until Inspector.clear_cache(), and table names up to 255 characters can be reflected (#771).NoSuchTableError from get_table_comment() and get_table_options() (#801). An empty Glue comment reflects as None (#782).JSON columns return the value Athena returns: type_coerce(literal_column("CAST('<text>' AS JSON)"), JSON) returns the str instead of decoding it a second time (use json_parse() for the parsed value), JSON objects and arrays no longer raise TypeError, and json_deserializer no longer applies to json results (#1010, #934).CREATE TABLE compression (#1025, #1020, #1015, #937):
awsathena_compression now get the requested codec: the DDL emits parquet.compression / write.compression, which Athena applies (it ignored the former properties and used GZIP). to_sql() tables also carry parquet.compression. Fix existing tables with ALTER TABLE ... SET TBLPROPERTIES.file_format is matched case-insensitively.kill_on_interrupt cancellation, Spark cursors re-raise KeyboardInterrupt / asyncio.CancelledError instead of returning or raising OperationalError (#833, #797).ClientRequestToken unless client_request_token is given, and an interrupt while a calculation is being started stops that calculation (#861, #841).The filesystem was audited against fsspec and s3fs and restructured around the typed S3Core. Behavior changes, by area:
Note truncated.
v3.40.0 is a minor release of the 3.x maintenance line. It backports bug fixes from master ( #1198 ). The 3.x line still supports Python 3.10 and sqla
v3.40.0 is a minor release of the 3.x maintenance line. It backports bug fixes from master (#1198). The 3.x line still supports Python 3.10 and sqlalchemy>=1.0.0.
Thanks to @greg-om for reporting the SQLAlchemy ping failure with unload=true (#1189) and fixing it (#1185).
unload=true, the connection ping (pool_pre_ping, and connection tests such as Apache Superset's) no longer fails with MISSING_COLUMN_NAME. The ping runs SELECT 1 through a plain Cursor instead of the connection's default cursor, while SQLAlchemy keeps its own handling of a failed ping, including is_disconnect() before SQLAlchemy 2.0.5 (#1185, #1189; #1200, #1199).PolarsCursor and AioPolarsCursor work with Polars 2.0 (#1169, #1168). Before, every query read from a CSV result file without chunksize failed with OperationalError (invalid value for 'connection'). The CSV result file is now read through PyAthena's S3 filesystem and passed to Polars as bytes, with Polars 1.x as well.Map, which the cursor description now reports as map. Before, it was string, or array/row when the map's values were lists or structs. With Polars 1.x, a map stays array. A struct containing a list is now described as row instead of array (#1169).PolarsCursor describes its columns as the UNLOAD statement's rows bigint column. Master fixed this in #1012, which is not on 3.x.Full Changelog: v3.39.0...v3.40.0
v3.39.0 is a minor release of the 3.x maintenance line. It backports bug fixes from master ( #1119 , #1121 , #1128 ). The 3.x line still supports Pyth
v3.39.0 is a minor release of the 3.x maintenance line. It backports bug fixes from master (#1119, #1121, #1128). The 3.x line still supports Python 3.10 and sqlalchemy>=1.0.0. The minimum tenacity version is raised to 8.0.1 (see Dependencies).
tenacity version is now 8.0.1 (was 4.1.0). Older releases break retry_api_call(): releases before 6.1.0 fail on Python 3.11+ (asyncio.coroutine was removed), and 8.0.0 raises TypeError from after_log on the first retry (#1126, #1105).ArrowCursor, AsyncArrowCursor, AioArrowCursor) reads result files with the connection session's credentials (#1116, #1115):
credential_process, IAM Identity Center, role_arn with source_profile) read result files with the profile's credentials instead of PyArrow's default credential chain.role_arn connection argument, PyArrow no longer assumes the role a second time; it reads with the role credentials the connection already obtained (including MFA via serial_number). These credentials expire after duration_seconds, as they do for the connection's boto3 clients.session=, the session's credentials are used, not aws_access_key_id/aws_secret_access_key connection arguments that the session was not built from.ARRAY['x', '', 'y'] used to come back as ['x', 'y'], and ARRAY['a,b', 'c'] as ['a', 'b', 'c']. Leading and trailing spaces of array items are kept (#1054, #1041).array(json), map(..., json), or row(... json) type hints, JSON string elements stay strings ("123" used to become 123), row(json) fields no longer raise JSONDecodeError, and array(json) values whose first element is not a string are parsed (they raised JSONDecodeError) (#1033, #1054).AttributeError / TypeError) (#1005).iter_chunks() (#1005).table_type property is ICEBERG (case-insensitive). A table whose properties mention table_type and iceberg without 'table_type'='ICEBERG' now compiles to CREATE EXTERNAL TABLE with the Hive layout (previously CREATE TABLE with the Iceberg layout). On an S3 Tables catalog, such a table raises CompileError ("S3 Tables support only Iceberg tables") (#1043, #1039).Full Changelog: v3.38.0...v3.39.0
v3.38.0 is a minor release of the 3.x maintenance line. It backports bug fixes from master ( #1104 , #903 ) and contains no breaking changes. The 3.x…
v3.38.0 is a minor release of the 3.x maintenance line. It backports bug fixes from master (#1104, #903) and contains no breaking changes. The 3.x line still supports Python 3.10 and sqlalchemy>=1.0.0, and its dependency requirements are unchanged.
It includes the fixes for the issues @aminghadersohi reported, #854 and #857, as well as @aminghadersohi's own fix #839. Thank you for the reports and the contribution.
map<...> columns are AthenaMap(key_type, value_type) instead of String. Top-level struct<...> / row(...) columns are AthenaStruct with their field types (#995, #857). A field, key, or value type that the dialect does not recognize is reflected as NullType with a warning.awsathena:// URL resolves to the REST dialect, the same as awsathena+rest://. Before, engine.driver raised AttributeError (#839).to_sql finds an existing table whatever the case of its name (#800, #799).TIMESTAMP WITH TIME ZONE values with a numeric UTC offset such as +05:30 convert to aware datetimes with a fixed offset instead of naive ones (#1033, #854). Values with a zone name are unchanged.for loop over an asyncio cursor or result set raises TypeError instead of never ending. Use async for (#899, #898).cache_size / cache_expiration_time) is no longer used for qmark queries with parameters. Before, it could return the result of an execution that ran with different parameters, because Athena does not return the parameters of earlier executions. A repeated qmark query with the same parameters is now executed again (#959, #941).chunksize, as_pandas() returns the whole result when auto_optimize_chunksize chose a chunk size. It used to return only the first chunk.as_pandas() call, or one made after rows were fetched, returns an empty DataFrame instead of raising StopIteration.PandasDataFrameIterator.as_pandas(), as returned by iter_chunks() or by as_pandas() with an explicit chunksize, keeps the chunks' index and categorical dtypes. With index_col, the joined DataFrame is indexed by that column instead of a new RangeIndex.engine="pyarrow", PandasCursor reads the tab-separated .txt results of DDL statements such as SHOW TABLES and DESCRIBE with the C engine, keeping leading zeros, exponent notation, and padding (#1075, #1073).as_arrow() holds. TIME, VARBINARY, and JSON values used to raise TypeError because the values were converted twice. A custom Arrow converter mapping is therefore not applied on this path, the same as for as_arrow() (#1023, #1021).PolarsDataFrameIterator stops for every reader kind (#1029, #1019).OperationalError when the session is terminated, degraded, or failed, instead of polling forever (#831, #792).AsyncSparkCursor.close() shuts down its executor even when session termination fails (#830, #795).write() no longer makes the multipart upload fail with EntityTooSmall (#947, #942).Full Changelog: v3.37.0...v3.38.0
v3.37.0 is a minor release of the 3.x maintenance line. It backports the SQLAlchemy ARRAY support and fixes from master ( #893 ). The 3.x line keeps s
v3.37.0 is a minor release of the 3.x maintenance line. It backports the SQLAlchemy ARRAY support and fixes from master (#893). The 3.x line keeps supporting Python 3.10 and sqlalchemy>=1.0.0.
array<...> columns are AthenaArray with their element types, instead of String, and types.ARRAY maps to AthenaArray (#774).Numeric precision and scale, to prevent silent rounding.CREATE TABLE renders STRUCT column types, including STRUCT values inside MAP and ARRAY, as Hive STRUCT<name:type>. Athena rejected the previous ROW(...) output (#870, #855). Thanks to @mvanhorn for the fix and @aminghadersohi for the report. Integers inside ARRAY, MAP, and STRUCT column types render as INT. Code that compares compiled DDL strings must expect STRUCT<...> and INT.CAST to Double or DOUBLE_PRECISION renders DOUBLE instead of the 32-bit REAL (#826).None (#770).Full Changelog: v3.36.0...v3.37.0
Add _escape_trino, keep _escape_presto as a backward-compatible alias by @laughingman7743 in #747
Full Changelog: v3.35.4...v3.36.0
Fix escaper selection for DELETE and CTAS to prevent SQL injection (CVE-2026-65321) by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pu…
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.35.3...v3.35.4
Bump setuptools from 78.1.1 to 83.0.0 by @dependabot[bot] in https://github.com/pyathena-dev/PyAthena/pull/741
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.35.2...v3.35.3
Bump soupsieve from 2.8 to 2.8.4 by @dependabot[bot] in https://github.com/pyathena-dev/PyAthena/pull/738
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.35.1...v3.35.2
Restore legacy keyword arguments on the private _execute() methods by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/735
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.35.0...v3.35.1
Centralize shared execute() kwargs into an ExecuteOptions dataclass by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/733
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.34.0...v3.35.0
Add filesystem API parity features to the built-in S3FileSystem by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/729
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.33.0...v3.34.0
Replace Makefile with just by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/725
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.32.0...v3.33.0
Add on_poll callback for real-time query monitoring (#723) by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/724
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.31.1...v3.32.0
Bump pyarrow from 18.1.0 to 23.0.1 by @dependabot[bot] in https://github.com/pyathena-dev/PyAthena/pull/720
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.31.0...v3.31.1
Bump requests from 2.32.4 to 2.33.0 by @dependabot[bot] in https://github.com/pyathena-dev/PyAthena/pull/699
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.30.1...v3.31.0
Move _normalize_hive_syntax to DefaultTypeConverter and fix pass stubs by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/695
_normalize_hive_syntax to DefaultTypeConverter and cleaned up pass stubs.All versions from v3.17.0 through v3.30.0 (released 2025-08-09 to 2026-02-28) are affected by this performance regression. The last unaffected version is v3.16.0.
If you cannot upgrade to v3.30.1, explicitly specify the C engine to bypass the incorrect engine selection:
cursor = connection.cursor(PandasCursor, engine="c")
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.30.0...v3.30.1
Add documentation for AioS3FileSystem and S3Executor by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/686
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.29.3...v3.30.0
Add S3Executor strategy pattern for async S3 operations by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/684
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.29.2...v3.29.3
Fix release workflow and split CI test jobs for independent retries by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/682
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.29.1...v3.29.2
Add async SQLAlchemy dialects for native asyncio support by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/679
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.29.0...v3.29.1
Add native asyncio cursor support (Phase 1) by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/666
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.28.0...v3.29.0
Update documentation domain to pyathena.dev by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/663
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.27.2...v3.28.0
Rewrite CLAUDE.md for maintainability by @laughingman7743 in https://github.com/pyathena-dev/PyAthena/pull/660
Full Changelog: https://github.com/pyathena-dev/PyAthena/compare/v3.27.1...v3.27.2
Fix README logo not displaying on PyPI by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/659
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.27.0...v3.27.1
Fix retry_api_call to use getEffectiveLevel() instead of logger.level by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/651
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.26.0...v3.27.0
Return DOUBLE type for double columns in SQLAlchemy 2.0+ by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/648
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.25.0...v3.26.0
Pass WorkGroup parameter to GetTableMetadata and ListTableMetadata APIs by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/646
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.24.1...v3.25.0
Unify _to_date converter and add git workflow guidelines by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/641
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.24.0...v3.24.1
Fix docs deployment from tag triggers by using workflow_dispatch by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/633
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.23.0...v3.24.0
Fix docs version detection for master branch builds by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/631
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.22.0...v3.23.0
Fix: Nested struct parsing fails to preserve nested fields (Issue #627) by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/628
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.21.1...v3.22.0
trailing slash check for s3_staging_dir by @CAinDE in https://github.com/laughingman7743/PyAthena/pull/626
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.21.0...v3.21.1
Drop Python 3.9 support after EOL by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/622
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.20.0...v3.21.0
docs: Implement version selector with sphinx-multiversion by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/613
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.19.0...v3.20.0
docs: Change Sphinx theme from Alabaster to Furo by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/606
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.18.0...v3.19.0
Introduce hatch-vcs for automatic version management by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/600
'NoneType' object has no attribute 'get' can happen on AWS retries by @chollinger93 in https://github.com/laughingman7743/PyAthena/pull/604Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.17.1...v3.18.0
Fix dynamic imports in SQLAlchemy dialect components by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/599
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.17.0...v3.17.1
Add Athena filter() function support to SQLAlchemy dialect by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/592
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.16.0...v3.17.0
feat: implement STRUCT type support for PyAthena SQLAlchemy dialect by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/587
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.15.0...v3.16.0
Add CLAUDE.md development guide for AI assistants by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/586
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.14.1...v3.15.0
Fix incompatible dtype conversions in dataframe. (fix #523) by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/585
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.14.0...v3.14.1
Add the import_dbapi method to classes that inherit AthenaDialect to suppress SQLAlchemy WARNING messages. (fix #582) by @laughingman7743 in https://g
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.13.0...v3.14.0
Comment out some test cases because of the high cost of AWS for testing by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/571
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.12.2...v3.13.0
Fix type hints by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/570
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.12.1...v3.12.2
Fix F821 Undefined name List and Union by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/569
List and Union by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/569Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.12.0...v3.12.1
Support Athena parameterized queries when paramstyle is qmark (fix #545) by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/557
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.11.0...v3.12.0
Drop support for Python 3.8 (fix #561) by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/565
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.10.0...v3.11.0
Fix to pass kwarg in the call to the execute method in the executemany method by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.9.0...v3.10.0
Bump urllib3 from 1.26.18 to 1.26.19 in /requirements by @dependabot in https://github.com/laughingman7743/PyAthena/pull/549
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.8.3...v3.9.0
Bump jinja2 from 3.1.3 to 3.1.4 in /requirements by @dependabot in https://github.com/laughingman7743/PyAthena/pull/542
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.8.2...v3.8.3
⚠️ This version may cause EntityTooSmall errors with multipart uploads. This will be fixed in the next version. ⚠️
⚠️ This version may cause EntityTooSmall errors with multipart uploads. This will be fixed in the next version. ⚠️
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.8.1...v3.8.2
Support for appending to files larger than 5GB by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/541
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.8.0...v3.8.1
⚠️ This version is not able to append to files larger than 5GB. This will be improved in the next version. ⚠️
⚠️ This version is not able to append to files larger than 5GB. This will be improved in the next version. ⚠️
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.7.0...v3.8.0
Add support for UPDATE and MERGE operation in formatter by @Oskar-Bonde in https://github.com/laughingman7743/PyAthena/pull/536
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.6.0...v3.7.0
Update README by @laughingman7743 in https://github.com/laughingman7743/PyAthena/pull/530
Full Changelog: https://github.com/laughingman7743/PyAthena/compare/v3.5.1...v3.6.0
One column per quarter.